饿汉模式：
饿汉模式的单例实例是在类装载时进行创建的，它是有JVM的机制保证的，所以它总是线程安全的：
/**
* 饿汉模式
* 单例实例在类装载时进行创建
*/
public class SingletonExample2 {
// 私有构造函数
private SingletonExample2() {
}
// 单例对象
private static SingletonExample2 instance = new SingletonExample2();
// 静态的工厂方法
public static SingletonExample2 getInstance() {
return instance;
}
}但是，它也有缺点：私有构造函数有太多逻辑需要处理的话，类装载将会变慢。并且该类如果在实际使用中没有被使用到的话，会造成资源的浪费。
懒汉模式演进：
首先我们先看一下最原始版的：
/**
* 懒汉模式
* 单例实例在第一次使用时进行创建
*/
public class SingletonExample1 {
// 私有构造函数
private SingletonExample1() {
}
// 单例对象
private static SingletonExample1 instance = null;
// 静态的工厂方法
public static SingletonExample1 getInstance() {
if (instance == null) {
instance = new SingletonExample1();
}
return instance;
}
}分析：假设两个线程同时进入到instance==null的判断，都判断成功了。然后一个线程被挂起了，另外一个线程执行了下一步，创建了一个新的实例出来。接着被挂起的线程恢复，又重新创建了一次。这样实际就相当于创建了两次，因此它是线程不安全的。
我们做进一步的演进，在getInstance方法上加synchronize关键字：
public class SingletonExample3 {
// 私有构造函数
private SingletonExample3() {
}
// 单例对象
private static SingletonExample3 instance = null;
// 静态的工厂方法
public static synchronized SingletonExample3 getInstance() {
if (instance == null) {
instance = new SingletonExample3();
}
return instance;
}
}分析：
因为加了synchronize，它在同一个时刻只能有一个线程进入该方法进行操作。因此它是线程安全的。但是，因为synchronize修饰的是静态方法，因此它的作用范围是所有的该类，这样导致的一个后果是，多个线程执行到该方法时，只能有一条线程进入到该方法，其他线程需要等待。这样代码执行效率就大大降低了。因此我们再做进一步的演进就是缩小synchronize的作用范围。
进一步演进：
public class SingletonExample4 {
// 私有构造函数
private SingletonExample4() {
}
// 单例对象
private static SingletonExample4 instance = null;
// 静态的工厂方法
public static SingletonExample4 getInstance() {
if (instance == null) { // 双重检测机制 // B
synchronized (SingletonExample4.class) { // 同步锁
if (instance == null) {
instance = new SingletonExample4(); // A - 3
}
}
}
return instance;
}
}分析：
我们缩小了锁的范围，并且使用了双重检测机制。但是这样的做法依然是线程不安全的。因为在instance = new SingletonExample4()发生了指令重排序。正常情况下，创建一个新的对象是由以下几个过程构成的：
1、分配对象的内存空间 memory=allocate()
2、初始化对象 ctorInstance()
3、设置instance指向刚分配的内存 instance=memory
由于JVM和CPU的优化，它可能会变成以下的顺序：
1、分配对象的内存空间 memory=allocate()
2、设置instance指向刚分配的内存 instance=memory
3、初始化对象 ctorInstance()
当一个线程进入到synchronize作用范围内，并在第二步中设置instance指向刚分配的内存，然后线程挂起，不执行第三步中的初始化操作。此时，虽然未进行初始化操作，但instance变量已经不为空了。当其他线程使用到了该对象，但是该对象并未被初始化，就会出现问题。因此该工厂是线程不安全的。
那有什么办法可以防止它重排序呢，那就是使用volatile关键字，我们的代码就可以进一步做一下演进：
/**
* 懒汉模式 -》 双重同步锁单例模式
* 单例实例在第一次使用时进行创建
*/
public class SingletonExample5 {
// 私有构造函数
private SingletonExample5() {
}
// 1、memory = allocate() 分配对象的内存空间
// 2、ctorInstance() 初始化对象
// 3、instance = memory 设置instance指向刚分配的内存
// 单例对象 volatile + 双重检测机制 -> 禁止指令重排
private volatile static SingletonExample5 instance = null;
// 静态的工厂方法
public static SingletonExample5 getInstance() {
if (instance == null) { // 双重检测机制 // B
synchronized (SingletonExample5.class) { // 同步锁
if (instance == null) {
instance = new SingletonExample5(); // A - 3
}
}
}
return instance;
}
}分析：由于使用volitale禁止了指令重排序，因此上述代码是线程安全的。
这里再介绍下使用枚举类来实现单例：
/**
* 枚举模式：最安全
*/
public class SingletonExample7 {
// 私有构造函数
private SingletonExample7() {
}
public static SingletonExample7 getInstance() {
return Singleton.INSTANCE.getInstance();
}
private enum Singleton {
INSTANCE;
private SingletonExample7 singleton;
// JVM保证这个方法绝对只调用一次
Singleton() {
singleton = new SingletonExample7();
}
public SingletonExample7 getInstance() {
return singleton;
}
}
}分析：因为enum枚举类线程安全的，它是由JVM底层来保证实现的。因为它是线程安全的，推荐使用这个方法。
当然还有其他使用内部类的方法来实现，有兴趣的可以自行百度下，这里就不做更多的赘述了。