单例模式

概念

单例模式：确保一个类只有一个实例，并提供一个全局访问点

三要素

1.私有静态属性，用于存取类的唯一实例。

2.公共静态方法，用于提供对该唯一实例的存取访问，如果实例未创建，则创建该实例 (静态变量只能在静态方法中应用)。

3.用于限制类再次实例化的方式。通常使用私有构建函数的方式来实现。

代码展示

饿汉模式

/**
 * 饿汉模式
 */
public class SingletonHunger {
    private static SingletonHunger singletonHunger;
    static {
        singletonHunger = new SingletonHunger();
    }
    private SingletonHunger(){
    }
    public static SingletonHunger getSingletonHunger() {
        return singletonHunger;
    }
}

懒汉模式

/**
 * 懒汉模式
 */
public class SingletonLazy {
        private static SingletonLazy singletonLazy;
        private SingletonLazy(){
        }
        public static SingletonLazy getSingletonLazy() {
            if(singletonLazy==null) {
                singletonLazy = new SingletonLazy();
            }
            return singletonLazy;
        }
}

双重加锁

/**
 * 双重加锁实现
 *
 * 另外需要注意的是双重加锁要对 instance 域加上 volatile 修饰符。
 * 由于 synchronized 并不是对 instance 实例进行加锁（因为现在还并没有实例），
 * 所以线程在执行完第11行修改 instance 的值后，应该将修改后的 instance 立即写入主存（main memory），
 * 而不是暂时存在寄存器或者高速缓冲区（caches）中，以保证新的值对其它线程可见。
 补充：第20行可以锁住任何一个对象，要进入临界区必须获得这个对象的锁。由于并不知道其它对象的锁的用途，
 所以这里最好的方式是对 Singleton.class 进行加锁。
 */
public class DoubleCheck {
    private volatile static DoubleCheck doubleCheck;
    private DoubleCheck(){};
    public static DoubleCheck getDoubleCheck() {
        if(doubleCheck==null){
            synchronized (DoubleCheck.class){//类锁，拦截所有线程
                doubleCheck =  new DoubleCheck();
            }
        }
        return doubleCheck;
    }
}