饿汉模式:
饿汉模式的单例实例是在类装载时进行创建的,它是有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底层来保证实现的。因为它是线程安全的,推荐使用这个方法。
当然还有其他使用内部类的方法来实现,有兴趣的可以自行百度下,这里就不做更多的赘述了。