单例模式大家并不陌生，分为饿汉式和懒汉式等。
线程安全的饿汉式单例
饿汉式单例在类第一次加载的时候就完成了初始化，上代码：
public class MyObject {
private static MyObject myObject = new MyObject();
public static MyObject getInstance(){
return myObject;
}
}
下面来验证饿汉式单例的线程安全性：
public class MyThread extends Thread{
public void run() {
System.out.println(MyObject.getInstance().hashCode());
}
}
public class Test {
public static void main(String[] args) throws Exception {
Thread t1 = new MyThread();
Thread t2 = new MyThread();
Thread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
}
}
输出：
763347431 763347431 763347431
三次输出 hashCode 是同一个值，说明饿汉式单例天生就是线程安全的。
结论：饿汉式单例在类第一次加载的时候完成初始化，而且是线程安全的。
非线程安全的懒汉式单例
懒汉式单例为延迟加载，调用 getInstance() 时才被创建，上代码：
public class MyObject {
private static MyObject myObject = null; public static MyObject getInstance(){
if(myObject == null){
myObject = new MyObject();
}
return myObject;
}
}
这种情况下肯定是非线程安全的。因为判断对象为空和创建对象是一个原子性操作，多线程访问产生竞态条件。（竞态条件：多线程并发中，正确的结果取决于多个线程的执行顺序）
下面做一下验证：
public class MyThread extends Thread{
public void run() {
System.out.println(MyObject.getInstance().hashCode());
}
}
public class Test {
public static void main(String[] args) throws Exception {
Thread t1 = new MyThread();
Thread t2 = new MyThread();
Thread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
}
}
输出：
2146509683 810456228 1996534722
hashcode 输出不同，很明显懒汉式单例不具有线程安全性。
结论：懒汉式单例在需要该实例的时候才会进行初始化（仅初始化一次），但却是非线程安全的。在单例类数量少的情况下，这样一个延迟加载和饿汉式单例相比在性能上又没有明显的差距，所以我一般不会选择这种初级的懒汉式单例。
基于 volatile 的 DCL 方案为懒汉式单例提供线程安全性
在懒汉式单例的基础上，我们做一些优化使其具有线程安全的特性。
第一次尝试：
为 getInstance() 加上 synchronized 关键字
public class MyObject {
private static MyObject myObject = null; synchronized public static MyObject getInstance(){
if(myObject == null){
myObject = new MyObject();
}
return myObject;
}
}
输出
2000544445 2000544445 2000544445
得到的是单例，不过如果多个线程频繁调用 getInstance() 的话将会导致程序执行效率非常低下：下个线程想要取得对象锁，必须等到上一个线程释放锁之后才可以继续执行。
第二次尝试：
同步代码块
public class MyObject {
private static MyObject myObject = null; public static MyObject getInstance() {
synchronized (MyObject.class) {
if (myObject == null) {
myObject = new MyObject();
}
}
return myObject;
}
}
输出
512965639 512965639 512965639
然而这种方法等同于上一种尝试，唯一区别就是多线程下，上一次尝试中线程被堵在门口一米处进不来，而这一次尝试中线程被堵在门口半米处进不来。
第三次尝试：
继续缩小同步的代码范围
public class MyObject {
private static MyObject myObject = null; public static MyObject getInstance() {
if (myObject == null) { synchronized (MyObject.class) {
myObject = new MyObject();
}
}
return myObject;
}
}
输出
1175759956 2000544445 2146509683
相比前面几次尝试，执行效率会有显著提升，但是无法得到单例。因为破坏了原子性。
第四次尝试：
下面的代码使用了 DCL（双检查锁机制 double check lock ）
public class MyObject {
private static MyObject myObject = null; public static MyObject getInstance() {
if (myObject == null) { synchronized (MyObject.class) {
if (myObject == null) {
myObject = new MyObject();
}
}
}
return myObject;
}
}
输出：
1320194849 1320194849 1320194849
然而此时就是线程安全了吗?
No~ 不过我给不出反例推到，大家有经验的请指教一下~
第五次尝试：
我们还需要为“单例”加上 volatile 关键字。
public class MyObject {
volatile private static MyObject myObject = null;
public static MyObject getInstance() {
if (myObject == null) {
synchronized (MyObject.class) {
if (myObject == null) {
myObject = new MyObject();
}
}
}
return myObject;
}
}
此时才算是线程安全。
回头来看，“单例” 为何必须用 volatile 修饰呢 ?
因为关键字 volatile 能够禁止指令重排序。
Example - “单例” 在没有 volatile 修饰的情况下，线程A 和线程B 都是第一次调用该单例方法，线程A 先执行构造方法；然而该构造方法是一个非原子操作，编译后生成多条指令，由于指令重排序，可能会先执行赋值操作（实际是在内存中开辟一片存储对象的区域后直接返回内存的引用），之后 myObject 便不为空了，但是实际的初始化操作却还没有执行，如果就在此时线程B 进入，就会看到一个不为空的但是不完整（没有完成初始化）的对象。而 volatile 关键字能够禁止指令重排序优化，从而安全的实现单例。
结论：基于 volatile的 DCL方案能够保留延迟加载的特性，同时赋予了该单例线程安全性。
静态内部类实现单例模式
public class MyObject {
private static class Holder{
private static MyObject myObject = new MyObject();
}
public static MyObject getInstance() {
return Holder.myObject;
}
}
怎样保证的线程安全? 会不会因为多个线程同时调用 getInstance() 出现指令重排导致初始化不完全呢?
JVM 在加载 class 之后就会进行类的初始化，在类的初始化期间，JVM 会去获取一个初始化锁，这个锁可以同步多个线程对同一个类的初始化，因此指令重排还是可能发生的，但是并不影响获得初始化锁的下一个线程，因为下一个线程进来的时候，上个线程已经完成了类的初始化。
从书上搞了个图过来：
结论：静态内部类实现的单例模式能够保证线程安全，同时具有延迟加载特性。而且代码够简洁哦。