一个单例模式的晋级过程(饿汉-懒汉-DCL-IoDH-枚举)

一个单例模式的晋级过程(饿汉-懒汉-DCL-IoDH-枚举)

什么是单例？

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

规则：

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

简单来说就是一个特殊的类只能创建一次。

单例有哪些运用场景？

Windows的任务管理器，回收站，网站的计数器，线程池，数据库连接池;

一下这些环境都可以考虑使用单例

1.需要生成唯一序列的环境
2.需要频繁实例化然后销毁的对象
3.创建对象时耗时过多或者耗资源过多，但又经常用到的对象
4.方便资源相互通信的环境

实现

1.饿汉式

**是否 Lazy 初始化：**否

**是否多线程安全：**是

**实现难度：**易

**描述：**这是最简单的实现方式。

public class Singleton {  
    //内部调用构造函数创建的一个对象
    private static Singleton instance = new Singleton();  
    //让构造函数为 private，这样该类就不会被实例化
    private Singleton (){}  
    //提供统一的外部访问方法，获取唯一可用的对象
    public static Singleton getInstance() {  
    	return instance;  
    }  
}

测试

public class Main {
   public static void main(String[] args) {
       
      //由于使用使用private构造函数私有化 所以使用new关键字创建对象会报错。
      //Singleton instance = new Singleton();
       
      //多次获取的是同一个对象
      Singleton instance1 = Singleton.getInstance();
      Singleton instance2 = Singleton.getInstance();
   }
}

优化-final

可以看到instance对象创建后是不会再被更改的，所以可以使用final关键字修饰一下。

    private static final Singleton instance = new Singleton(); 

2.懒汉式

**是否 Lazy 初始化：**是

**是否多线程安全：**否

**实现难度：**易

**描述：**这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

public class Singleton {  
	//先定义一个空印用，等待后续赋值
    private static Singleton instance;  
    //让构造函数为 private，这样该类就不会被实例化
    private Singleton (){}  
  	//获取实例时先判断是否为空,是否需要创建一个对象。
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
    	return instance;  
    }  
}

优化-加锁同步

由于getInstance方法在多线程情况瞎可能会存在线程安全问题，所以可以把getInstance方法加锁,来保证线程安全

    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
    	return instance;  
    }  

**是否多线程安全：**是

由于对getInstance()方法做了同步处理，synchronized将导致性能开销。如果getInstance()方
法被多个线程频繁的调用，将会导致程序执行性能的下降。反之，如果getInstance()方法不会被
多个线程频繁的调用，那么这个延迟初始化方案将能提供令人满意的性能。

在早期的JVM中，synchronized（甚至是无竞争的synchronized）存在巨大的性能开销。因此，
人们想出了一个“聪明”的技巧：双重检查锁定（Double-Checked Locking）。人们想通过双重检查
锁定来降低同步的开销。下面来介绍双重检查锁定来实现延迟初始化。

3.DCL双检锁/双重校验锁

即double-checked locking

**JDK 版本：**JDK1.5 起

**是否 Lazy 初始化：**是

**是否多线程安全：**是

**实现难度：**较复杂

**描述：**这种方式采用双锁机制，安全且在多线程情况下能保持高性能。
getInstance() 的性能对应用程序很关键。

public class Singleton {  
    private static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
        if (singleton == null) {  						//第一次检查
            synchronized (Singleton.class) {  			//加锁
                if (singleton == null) {  				//第二次检测
                    singleton = new Singleton();  		//【注意此处有问题】
                }  
            }  
        }  
    return singleton;  
    }  
}

重排序问题

如果第一次检查instance不为null，那么就不需要执行下面的加锁和初始化操作。因此，可以大幅降低synchronized带来的性能开销。多个线程试图在同一时间创建对象时，会通过加锁来保证只有一个线程能创建对象。在对象创建好之后，执行getInstance()方法将不需要获取锁，直接返回已创建好的对象。

双重检查锁定看起来似乎很完美，但这是一个错误的优化！在线程执行到第一次检测时，代码读取到instance不为null时，instance引用的对象有可能还没有完成初始化.

注意上述代码种表注了一个问题。new Singleton();在JVM中可以分解为一下三个步骤

memory = allocate();　　// 1：分配对象的内存空间
ctorInstance(memory);　 // 2：初始化对象
instance = memory;　　  // 3：设置instance指向刚分配的内存地址

上面3行伪代码中的2和3之间，可能会被重排序（在一些JIT编译器上，这种重排序是真实发生的）。2和3之间重排序之后的执行时序如下。

memory = allocate();　　// 1：分配对象的内存空间
instance = memory;　　  // 3：设置instance指向刚分配的内存地址
// 注意，此时对象还没有被初始化！
ctorInstance(memory);　 // 2：初始化对象

也就是说，在多线程环境下，可能会有一下的执行顺序

多线程执行时序表

线程A	线程B
A1:分配对象的内存空间
A3:设置instance指向内存空间
	B1:第一次检测非空状态
	B2:由于instance不为空,线程B开始印用instance的对象
A2:初始化对象
A4:访问instance对象

上面错误双重检查锁定的示例代码中，如果线程A 获取到锁进入创建对象实例，这个时候发生了指令重排序。当线程A执行到 A3 时刻，线程 B 刚好进入，由于此时对象已经不为 Null，所以线程 B 可以自由访问该对象。然后该对象还未初始化，所以线程 B 访问时将会发生异常。

此问题的主要原因就是发生了指令重排序；

volatile 作用

正确的双重检查锁定模式需要使用 volatile。volatile主要包含两个功能。

1. 保证可见性。使用 volatile 定义的变量，将会保证对所有线程的可见性。
2. 禁止指令重排序优化。

由于 volatile 禁止对象创建时指令之间重排序，所以其他线程不会访问到一个未初始化的对象，从而保证安全性。

注意，volatile禁止指令重排序在 JDK 5 之后才被修复

也就是将Singleton声明为volatile 类型即可解决问题

优化-基于volatile 的双重检查锁

public class Singleton {  
    private static volatile Singleton singleton;  	//加上volatile
    private Singleton (){}  
    public static Singleton getSingleton() {  
        if (singleton == null) {  						
            synchronized (Singleton.class) {  			
                if (singleton == null) {  				
                    singleton = new Singleton();  		
                }  
            }  
        }  
    return singleton;  
    }  
}

4.IODH按需初始化持有者

即Initialization On Demand Holder idiom

**是否 Lazy 初始化：**是

**是否多线程安全：**是

**实现难度：**一般

**描述：**这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟饿汉式不同的是：饿汉式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比饿汉式就显得很合理。

public class Singleton {  
	//定义一个私有内部类
    private static class SingletonHolder {  
    	private static final Singleton INSTANCE = new Singleton();  
    } 
    //私有构造方法
    private Singleton (){}
    //这里将导致InstanceHolder类被初始化
    public static final Singleton getInstance() {  
    	return SingletonHolder.INSTANCE;  
    }  
    
}

两个线程并发执行getInstance()方法，下面是执行的示意图，图来自于《Java并发编程的艺术》

这个方案允许new Singleton(); 创建时的重排序，但不允许非构造线程（这里指线程B）“看到”这个重排序。

反射问题

好了现在已经有了很多种的实现方式了。也解决了线程安全和按需加载的问题。下面说一个让人绝望的问题。

如果客户端使用反射机制，借助AccessibleObject.setAccessible(true)方法，那么就可以用反射的方式调用private修饰的私有方法。 辛辛苦苦大半年，一个反射回到解放前。

public static void main(String[] args) throws Exception  {
    Class<?> classType = Singleton.class;  
    Constructor<?> c = classType.getDeclaredConstructor(null); 
	c.setAccessible(true);  
	Singleton s1 = (Singleton)c.newInstance();
	Singleton s2 = Singleton.getInstance();
	System.out.println(s1==s2);
}  

继续优化

参考《effective java3》第3条 用私有构造器或者枚举类型强化 Singleton属性

私有构造函数异常处理

public class Singleton {  
	pprivate static volatile boolean flag = false; 
    //私有构造方法
    private Singleton (){
    	synchronized(Singleton.class){
    	    if(flag == false)  {  
                flag = !flag;  
            }else {
                throw new RuntimeException("狗东西你想干吗？");  
            }  
    	}
    }
    
    //定义一个私有内部类
    private static class SingletonHolder {  
    	private static final Singleton INSTANCE = new Singleton();  
    } 
    //这里将导致InstanceHolder类被初始化
    public static final Singleton getInstance() {  
    	return SingletonHolder.INSTANCE;  
    }  
    
}

5.枚举实现单例

**JDK 版本：**JDK1.5 起

**是否 Lazy 初始化：**否

**是否多线程安全：**是

**实现难度：**易

**描述：**这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。
不能通过 reflection attack 来调用私有构造方法。

public enum Singleton{
	INSTANCE;
}

使用推荐

一般情况下，不建议使用懒汉式，建议使用线程安全的饿汉式。只有在要明确实现 lazy loading 效果时，才会使用IODH的方式。如果涉及到反序列化创建对象时，可以尝试使用枚举方式。如果有其他特殊的需求，可以考虑使用双检锁方式。

参考

《java并发编程的艺术》

《effective java3》

菜鸟教程-单例模式

为什么双重检查锁模式需要 volatile ？

看到这的有小礼物呦!!!