单例模式

饿汉式

public class Singleton {  
    private static Singleton instance = new Singleton();  
    
    private Singleton (){}  
    
    public static Singleton getInstance() {  
    	return instance;  
    }  
}

• 它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，浪费内存

懒汉式

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

• 线程安全，但是再getInstance方法上加锁，加锁的范围过大，如果instance不为空也需要经过锁，效率低

双重检查锁（DCL，即 double-checked locking）

public class Singleton{
    private volatile static Singleton instance;
    
    private Sinleton(){}
    
    public static Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

• 锁的范围小，如果instance不为空直接返回，不用经过锁

• DCL是否要配合volatile使用？不用volatile可以吗？

  • CPU和编译器为了提升程序的执行效率, 通常会按照一定的规则对指令进行优化, 如果两条指令互不依赖, 有可能它们执行的顺序并不是源代码编写的顺序。比如正常情况下 instance = new Instance()可以分成三步:

    • 分配对象内存空间
    • 初始化对象
    • 设置instance指向刚刚分配的内存地址, 此时instance != null (重点)

    因为2 3步不存在数据上的依赖关系, 即在单线程的情况下, 无论2和3谁先执行, 都不影响最终的结果, 所以在程序编译时, 有可能它的顺序就变成了

    • 分配对象内存空间
    • 设置instance指向刚刚分配的内存地址, 此时instance != null (重点)
    • 初始化对象

    但是, CPU和编译器在指令重排时, 并不会关心是否影响多线程的执行结果。在不加volatile关键字时, 如果有多个线程访问getInstance方法, 此时正好发生了指令重排, 那么可能出现如下情况:
    当第一个线程拿到锁并且进入到第二个if方法后, 先分配对象内存空间, 然后再instance指向刚刚分配的内存地址, instance 已经不等于null, 但此时instance还没有初始化完成。如果这个时候又有一个线程来调用getInstance方法, 在第一个if的判断结果就为false, 于是直接返回还没有初始化完成的instance, 那么就很有可能产生异常。

    那么加了volatile之后会有什么不同呢? volatile有三个特点:

    1. 保证可见性
    2. 不保证原子性
    3. 禁止指令重排

    加了volatile关键字之后, 会强制cpu和编译器按照顺序执行代码, 所以就不用担心指令重排导致上面的问题了。

枚举实现单例

public enum Singleton{
    INSTANCE;
    public void doSomething(){
        
    }
}

• 这种方式更简洁，自动支持序列化机制，绝对防止多次实例化