单例模式

饿汉式单例：

public class Singleton {

    private static Singleton singleton = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return singleton;
    }
} 

懒汉式单例：

public class Singleton {

    private static Singleton singleton;

    private Singleton() {}

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

 

双检锁/双重校验锁（DCL，即 double-checked locking）

使用双重检测同步延迟加载去创建单例的做法是一个非常优秀的做法，其不但保证了单例，而且在多线程情况下能保持高性能，对应的例子代码清单如下：

 

public class Singleton {
    
    private volatile static Singleton singleton;

    private Singleton() {}

    public static Singleton getInstance() {
        // 第一次判断
        if (singleton == null) {
            // 竞争锁
            synchronized (Singleton.class) {
                // 第二次判断
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

双检锁机制要特别注意两点：

（1）必须使用volatile关键字修饰单例引用。

volatile关键字禁止了指令的重排序。

singleton = new Singleton 这句若没有重排序，那么步骤为：1、为实例singleton开辟内存空间，2、初始化singleton，3、singleton指向内存空间。

如果发生了重排序，那么步骤可能变成：1、为实例singleton开辟内存空间，2、singleton指向内存空间，3、初始化singleton。

当singleton指向了内存空间，那么singleton就已经不为null，如果此时有其他线程在第一次进行了判断，由于singleton不为null就会直接返回singleton，但这时的singleton是还未初始化的实例，于是发生了线程不安全的现象。

（2）必须要有双重判断。

第一次判断主要目的是已经存在了一个实例对象，后续就不会进入到锁竞争的操作，提高了效率

假设第一次执行时多个线程同时进入了竞争锁阶段，此时A线程获得了锁，那么其他线程等待锁，接着A线程完成了singleton的初始化，返回singleton，但这个时候，由于多个线程已经进入到竞争锁的阶段，但由于singleton单例已经生成，如果此时没有对singleton进行判空，那么就会对singleton再次进行初始化操作，出现线程不安全问题，所以第二次的判空处理是必须要的。

登记式/静态内部类

public class Singleton {
    
    private Singleton() {}

    private static class Holder {
        private static Singleton singleton = new Singleton();
    }

    public static Singleton getInstance() {
        return Holder.singleton;
    }
}

（未完待续）