单例模式
什么是单例模式
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式。在 GOF 书中给出的定义为：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
单例模式一般体现在类声明中，单例的类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
优点
单例模式有以下两个优点：
在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如网站首页页面缓存）。
避免对资源的多重占用（比如写文件操作）。
有时候，我们在选择使用单例模式的时候，不仅仅考虑到其带来的优点，还有可能是有些场景就必须要单例。比如类似"一个党只能有一个主席"的情况。
分类
①饿汉式
/**
* <Description>饿汉式单例模式<br>
*
* @author DaShi<br>
* @version 1.0<br>
* @taskId <br>
* @CreateDate 2018/12/20 10:11 <br>
*/
public class Singleton {
//内部实例化
private static Singleton singleton = new Singleton();
//私有的构造方法 外部不可见
private Singleton(){
}
//对外部提供静态方法 直接返回实例
public static Singleton getInstance(){
return singleton;
}
//test
public static void main(String[] args){
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println (singleton1==singleton2);
System.out.println(singleton1);
System.out.println(singleton2);
}
}
image.png
以上就是一个简单的单例的实现，这种实现方式我们称之为饿汉式。所谓饿汉。这是个比较形象的比喻。对于一个饿汉来说，他希望他想要用到这个实例的时候就能够立即拿到，而不需要任何等待时间。所以，通过static的静态初始化方式，在该类第一次被加载的时候，就有一个SimpleSingleton的实例被创建出来了。这样就保证在第一次想要使用该对象时，他已经被初始化好了。
同时，由于该实例在类被加载的时候就创建出来了，所以也避免了线程安全问题。（原因见：在深度分析Java的ClassLoader机制（源码级别）、Java类的加载、链接和初始化）
②饿汉模式的变种：
import sun.java2d.pipe.SpanShapeRenderer;
/**
* <Description>饿汉式单例模式<br>
*
* @author DaShi<br>
* @version 1.0<br>
* @taskId <br>
* @CreateDate 2018/12/20 10:11 <br>
*/
public class Singleton {
//内部先定义对象
private static Singleton singleton;
//实例化一哈！！！
static{
singleton = new Singleton();
}
//私有的构造方法 外部不可见
private Singleton(){
}
//对外部提供静态方法 直接返回实例
public static Singleton getInstance(){
return singleton;
}
//test
public static void main(String[] args){
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println (singleton1==singleton2);
System.out.println(singleton1);
System.out.println(singleton2);
}
}
结果①上方一致，我就不贴了
总结：
饿汉式单例，在类被加载的时候对象就会实例化。这也许会造成不必要的消耗，因为有可能这个实例根本就不会被用到。而且，如果这个类被多次加载的话也会造成多次实例化。其实解决这个问题的方式有很多，下面提供两种解决方式，第一种是使用静态内部类的形式。第二种是使用懒汉式。
③静态内部类式
/**
* <Description>静态内部类式单例<br>
*
* @author DaShi<br>
* @version 1.0<br>
* @taskId <br>
* @CreateDate 2018/12/20 11:07 <br>
*/
public class StaticInnerSingleton {
//在静态内部类中创建实例
private static class singletonHolder{
private static final StaticInnerSingleton staticInnerSingleton = new StaticInnerSingleton();
}
//私有的构造方法
private StaticInnerSingleton(){
}
//对外的获取实例的静态方法
public static StaticInnerSingleton getInstance(){
return singletonHolder.staticInnerSingleton;
}
}
饿汉式是一旦类加载了就会有实例，而这种方法即使你加载了类也不会产生实例，只有在你调用getInstance方法时，实例才会产生。
下面看另外一种在该对象真正被使用的时候才会实例化的单例模式—懒汉模式。
④懒汉式
import sun.java2d.pipe.SpanShapeRenderer;
/**
* <Description>懒汉式单例模式<br>
*
* @author DaShi<br>
* @version 1.0<br>
* @taskId <br>
* @CreateDate 2018/12/20 10:11 <br>
*/
public class Singleton {
//内部先定义对象
private static Singleton singleton;
//私有的构造方法
private Singleton(){
}
//对外的公共方法 返回实例
public static Singleton getInstance(){
if(null == singleton){
singleton = new Singleton();
}
return singleton;
}
}
这种懒汉式单例其实还存在一个问题，那就是线程安全问题。在多线程情况下，有可能两个线程同时进入if语句中，这样，在两个线程都从if中退出的时候就创建了两个不一样的对象。（我还没学到多线程呢！！！）。
⑤线程安全的懒汉式
针对线程不安全的懒汉式的单例，其实解决方式很简单，就是给创建对象的步骤加锁：
import sun.java2d.pipe.SpanShapeRenderer;
/**
* <Description>懒汉式单例模式<br>
*
* @author DaShi<br>
* @version 1.0<br>
* @taskId <br>
* @CreateDate 2018/12/20 10:11 <br>
*/
public class Singleton {
//内部先定义对象
private static Singleton singleton;
//私有的构造方法
private Singleton(){
}
//对外的公共方法 返回实例 加了个锁
public static synchronized Singleton getInstance(){
if(null == singleton){
singleton = new Singleton();
}
return singleton;
}
}
这种写法能够在多线程中很好的工作，而且看起来它也具备很好的延迟加载，但是，遗憾的是，他效率很低，因为99%情况下不需要同步。（因为上面的synchronized的加锁范围是整个方法，该方法的所有操作都是同步进行的，但是对于非第一次创建对象的情况，也就是没有进入if语句中的情况，根本不需要同步操作，可以直接返回instance。）
⑥双重校验锁
针对上面code 6存在的问题，相信对并发编程了解的同学都知道如何解决。其实上面的代码存在的问题主要是锁的范围太大了。只要缩小锁的范围就可以了。那么如何缩小锁的范围呢？相比于同步方法，同步代码块的加锁范围更小。
import sun.java2d.pipe.SpanShapeRenderer;
/**
* <Description>双重校验锁<br>
*
* @author DaShi<br>
* @version 1.0<br>
* @taskId <br>
* @CreateDate 2018/12/20 10:11 <br>
*/
public class Singleton {
//内部先定义对象
private static Singleton singleton;
//私有的构造方法
private Singleton(){
}
//对外的公共方法 返回实例
public static Singleton getInstance(){
if(null == singleton) {
//我们在里面加锁
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
案例⑥算是对案例⑤的一种改进，通过使用同步代码块的方式减小了锁的范围。这样可以大大提高效率。（对于已经存在singleton的情况，无须同步，直接return）。
但是，事情这的有这么容易吗？上面的代码看上去好像是没有任何问题。实现了惰性初始化，解决了同步问题，还减小了锁的范围，提高了效率。但是，该代码还存在隐患。隐患的原因主要和Java内存模型（JMM）有关
线程A发现变量没有被初始化, 然后它获取锁并开始变量的初始化。
由于某些编程语言的语义，编译器生成的代码允许在线程A执行完变量的初始化之前，更新变量并将其指向部分初始化的对象。
线程B发现共享变量已经被初始化，并返回变量。由于线程B确信变量已被初始化，它没有获取锁。如果在A完成初始化之前共享变量对B可见（这是由于A没有完成初始化或者因为一些初始化的值还没有穿过B使用的内存(缓存一致性)），程序很可能会崩溃。
使用volatile关键字的双重校验锁
import sun.java2d.pipe.SpanShapeRenderer;
/**
* <Description>使用volatile关键字的双重校验锁<br>
*
* @author DaShi<br>
* @version 1.0<br>
* @taskId <br>
* @CreateDate 2018/12/20 10:11 <br>
*/
public class Singleton {
//内部先定义对象 使用volatile关键字
private static volatile Singleton singleton;
//私有的构造方法
private Singleton(){
}
//对外的公共方法 返回实例
public static Singleton getInstance(){
if(null == singleton) {
//我们在里面加锁
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
上面这种双重校验锁的方式用的比较广泛，他解决了前面提到的所有问题。但是，即使是这种看上去完美无缺的方式也可能存在问题，那就是遇到序列化的时候。
使用final关键字的双重校验锁
/**
* <Description>使用final关键字的双重校验锁<br>
*
* @author DaShi<br>
* @version 1.0<br>
* @taskId <br>
* @CreateDate 2018/12/20 14:15 <br>
*/
public class FinalSingleton {
private FinalWrapper<FinalSingleton> helperWrapper = null;
public FinalSingleton getHelper() {
FinalWrapper<FinalSingleton> wrapper = helperWrapper;
if(null == wrapper){
synchronized (this) {
if (helperWrapper == null) {
helperWrapper = new FinalWrapper<FinalSingleton>(new FinalSingleton());
}
wrapper = helperWrapper;
}
}
return wrapper.value;
}
}
这个我没看懂啊0.0
⑦枚举式
public enum Singleton {
INSTANCE;
public void Singleton() {
}
}
这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象（下面会介绍），可谓是很坚强的壁垒啊，在深度分析Java的枚举类型—-枚举的线程安全性及序列化问题中有详细介绍枚举的线程安全问题和序列化问题，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过，但是不代表他不好。
⑧单例与序列化
单例和序列化之前的关系——序列化可以破坏单例。要想防止序列化对单例的破坏，只要在Singleton类中定义readResolve就可以解决该问题：
public class Singleton implements Serializable{
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
private Object readResolve() {
return singleton;
}
}
总结
本次主要介绍了包括饿汉、懒汉、使用静态内部类、双重校验锁、枚举等。还介绍了如何防止序列化破坏类的单例性。
另外,我需要理解一下volatile，synchronized关键字.
