Java实现线程安全的单例模式

单例模式：保证某个类在程序中只存在唯⼀⼀份实例，而不会创建出多个实例，单例模式的类一般是构造器私有，通过一个方法返回唯一实例；

点这里查看线程安全的详细讲解；

常见的单例模式分为饿汉式和懒汉式

一、饿汉式

饿汉式会在类加载的时候创建对象并初始化；

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

以上是一个饿汉式实现的单例模式的典型代码；由代码可以看出， 在类加载的时候对象已经创建好了，也就是不管你需不需要使用，都已经存在了，由 getInstance 方法返回这个对象，getInstance 方法直接 return，只涉及到读操作，不涉及写操作，因此饿汉式是线程安全的；

二、懒汉式

懒汉式在类加载的时候并不会直接创建出实例，而是在第一次使用的时候才会创建；

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

以上代码是懒汉式实现的单例模式的典型代码；其中， 刚开始的时候，instance 对象并没有实例化，在使用 getInstance 方法获取该对象时，会判断该对象是否为空，为空才会初始化（也就是第一次使用的时候为空），之后使用就会直接返回该对象；但是 getInstance 方法既存在读操作，也存在写操作 instance = new Singleton(); ，那么在多线程的情况下，是否会存在线程安全问题呢？答案是肯定的，试想如果两个线程同时执行到 if 判断，此时 instance 为空，两个线程都会进入 if 语句内，这样两个线程就会各自创建两个对象并返回，这就违背了单例模式的初衷；

那么如何解决这个问题呢？

优化一

可以使用 synchronized 加锁，由于两个线程不应该同时判断出 instance == null，故可以对整个 if 块使用 synchronized 进行加锁；于是代码就变为：

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

这样一来，在多线程的情况下，当一个线程进入到 if 块内，其他线程就会阻塞等待，等待出了synchronized 块之后，instance 实例也就 new 完了，其他线程再进行判断 instance 就不为 null 了，但是这样一来，之后的每次调用 getInstance 方法都会进行加锁，释放锁等操作，这样系统开销就非常大，影响效率，而我们只需要在第一次创建实例的时候加锁，因此即为了保证线程安全，又要保证效率，就得对上述代码进一步优化；

优化二

由于我们只需要在第一次创建实例的时候才加锁，因此可以在 synchronized 外面再包装一层 if 判断，于是代码进一步变为：

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

这样一来，既保证了线程安全，又不会非常影响效率，但是上述代码还存在一个问题：指令重排序问题，在 new Singleton() 实例的时候，new 操作可以被拆分为三步：

1）申请内存空间；

2）在内存空间上构造对象；

3）把内存地址赋值给实例引用；

编译器为了执行效率，会优化这三步的顺序，但是 1 肯定是最先执行的，因此 new 操作可能的执行顺序为 1 -> 2 -> 3，1 -> 3 -> 2，当执行顺序为后者的时候，假设有两个线程 t1，t2，在 t1 执行完 1, 3 还来不及执行 2 的时候，此时 t2 线程执行到 if 判断，此时由于 t1 线程执行了步骤 3 ，所以 t2 判断 if 不为 null，就直接返回 instance 对象了，但此时 instance 指向的是一个还没有初始化的非法对象，因此 t2 线程的后续代码访问 instance 里面的属性和方法时就会出错，为了避免这种情况，需要对上述代码再进行优化；

优化三

使用 volatile 关键字，告诉编译器不要优化指令重排序；

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

至此，线程安全的懒汉式就实现了；