java单例模式

定义

一个类只有一个实例，自行实例化并提供给整个系统

基本思路

将该类构造函数私有化，并通过静态方法获取一个唯一实例，获取过程保证线程安全

懒汉式线程不安全写法

public class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

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

假设有A、B线程同时调用getInstance方法，在分水岭同时执行完判断后，有CPU时间片切换，假设A线程得到执行权，继续向下执行，实例化了对象，此时instance不为空，而B线程又做了实例化工作，就会导致实例不唯一。

懒汉式线程安全

public class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

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

}

在getInstance()方法前加上synchronized，使整个方法同步，就可以保证线程安全，避免多实例的问题，但是这样并不高效，因为在第一次调用getInstance()方法后，instance不为空，之后再调用该方法就要走同步，这样会消耗不必要的资源。

Double Check Lock(双重检验锁)

public class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

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

}

这里为啥要做两次检验呢？我们先来看下，如果去掉第一层检验会怎样

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

当有两个线程同时调用getInstance()方法时，由于同步机制的存在，假设此时A线程得到CPU的执行权，走到同步块中执行，执行了instance = new Singleton()后，退出同步语句块，此时instance已经不为null了，这时候B线程获得CPU执行权也进入同步块，就会被instance == null的判断挡在外面了。所以就算不要第一层检验也是可以实现多线程安全的单例，那为毛还要写？原来这里涉及到性能问题，上面懒汉式线程安全的写法也是安全的，但是每次调用都要走同步会影响性能，这里也一样。我们希望这里的new Singleton()只执行一次，如果少了第一层的判断，每次有线程进入getInstance()时，均会执行锁定操作来实现线程同步，这是非常耗费性能的，而多了第一层检验，只要第一次instance==null会执行锁定操作，之后的调用直接return instance就行。
再看如果少了第二层检验，其实这就跟第一种懒汉式线程不安全写法一样，在多线程并发的情况下不能达到保持单例的效果。
那么双重检验机制是否就能完美解决问题？其实不然，其原因在于instance == new Singleton();这句并非是个原子操作，当JVM执行到这一句时，分别作了如下操作：

1. 在堆中为instance 分配内存
2. 调用Singleton的构造函数初始化成员变量
3. 将instance对象执行分配的内存空间（执行完这步instance就为非null了）
   如果上面的操作按1-2-3顺序执行，那就没啥问题，但是由于JVM的即时编译器中存在指令重排序的优化，上面的操作有可能是1-3-2。这会出现啥情况？

public static Singleton getSingleton() {
    if (instance == null) {        //p2                 
        synchronized (Singleton.class) {
            if (instance == null) {                
                instance = new Singleton(); //p1
            }
        }
    }
    return instance ;
  }

假设线程A此时走到p1处，JVM按照1-3-2的顺序实例化instance，才执行完1-3，来不及执行2，线程B获得了CPU执行权也调用了getInstance()方法，并走到p2处，此时instance不为null，线程B就屁颠屁颠拿着得到的实例回去干活了，但是里头的成员变量还没初始化，这就尴尬了，报错也就理所当然了。
要解决这问题只要把instance设置成volatile，禁止重排序优化，以上面的例子，不管是1-2-2还是1-3-2，读取必须在操作完全执行完后才能进行。

public class Singleton {

    private volatile static Singleton instance;

    private Singleton() {
    }

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

}

然而java5以前的版本使用volatile还是有问题，也不能完全避免重排序。

恶汉式

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {
    }

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

由于instance被static和final修饰，在该类第一次被加载到内存中时就会对instance实例化，这样保证了单例。缺点是就算其他地方没有调用getInstance()方法，也会创建实例。

静态内部类

public class Singleton {

    private Singleton() {
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

}

静态内部类就比较好的弥补了恶汉式单例不足，也是比较推崇的写法。