java之单例模式

单例模式：私有化构造器，并提供公有的获取实例的方法。

1. 饿汉式：程序一开始就创建一个对象；缺点是若不使用该对象，也会占用一块内存，当对象耗费资源较多时，是一种浪费。

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

2. 懒汉式:用的时候创建

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

3. 高并发下的懒汉模式

public class Singleton {
    private volatile static Singleton singleton;
    private Singleton() {
    }

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

1）内侧的if判断语句：出于线程安全的考虑

synchronized (Singleton.class) {
    if (null == singleton) {
        singleton = new Singleton();
    }
}

多线程并发执行，可能会产生多个实例。使用同步锁后，线程一得到同步锁，对象为空，则进入if，去new对象，别的线程会被阻塞。直到线程一new出对象，释放同步锁。此时别的线程得到同步锁后，也不符合为空的判断条件，即不会再次new对象。所以使用synchronized锁，可以很好的解决线程并发的问题。

2）外侧的if判断语句：提高执行效率

if (null == singleton) {
    synchronized (Singleton.class) {
        if (null == singleton) {
            singleton = new Singleton();
        }
    }
}

若只有同步锁，会有性能损失，当对象创建以后，每次获取实例时，都会执行同步锁，而产生多余的开销。
为避免这种开销，在锁的外边先判断一次对象是否为空，这样就提高了执行效率。

面对高并发下的懒汉模式，最安全、高效的选择就是双重if判断加同步锁的方式。

3) vloatile关键字解释：

singleton = new Singleton();

对于这句，不是一个原子操作，jvm大概做了以下三件事：

(1) 给对象分配内存

(2) 调用构造函数初始化这块内存

(3) 使变量singleton指向这块内存空间

只有执行完(3)，singleton才不为null。但在jvm的即时编译器中，存在指令重排序的优化。即(2)和(3)的执行顺序不能保证，可能是(1)(2)(3)，也可能是(1)(3)(2)。若是后者，执行完(3)但未执行(2)，此时释放同步锁，会被线程二抢占，此时线程二得到的singleton已经非null了，但还未初始化。所以线程二会直接返回 singleton，然后使用，就会报错。

此时只需将 singleton 变量声明成 volatile 就可以了，即禁止指令重排序优化，其执行顺序就是(1)(2)(3)。

volatile关键字保证了 singleton 在不同线程间的可见性，也就是说在多线程环境下，看到的仍然是最新修改的值。

4 参考：

真的会写单例吗？