创建型模式-单例设计-懒汉式
1. 懒汉式(线程不安全)
代码:
/**
* 单例 - 懒汉 - 线程不安全
*/
public class SingletonThreadUnsafe {
private static SingletonThreadUnsafe instance;
// 1. 构造方法私有化 -单例模式都需要这么做
private SingletonThreadUnsafe(){}
// 2. 提供一个静态的公有方法,当使用到该方法时,才会去创建实例-即懒汉模式
public static SingletonThreadUnsafe getInstance(){
if(instance== null){
instance = new SingletonThreadUnsafe();
}
return instance;
}
}
测试:
class SingletonThreadUnsafeTest {
@Test
void getInstance() {
System.out.println("懒汉式 1 , 线程不安全~");
SingletonThreadUnsafe s1 = SingletonThreadUnsafe.getInstance();
SingletonThreadUnsafe s2 = SingletonThreadUnsafe.getInstance();
System.out.println(s1 == s2); // true
System.out.println("s1.hashCode=" + s1.hashCode());
System.out.println("s2.hashCode=" + s2.hashCode());
}
}
说明:
- 起到了 Lazy Loading 的效果,但是只能在单线程下使用。
- 如果在多线程下,一个线程进入了 if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会 产生多个实例。所以在多线程环境下不可使用这种方式
- 结论:在实际开发中, 不要使用这种方式.
2. 懒汉式(线程安全,同步方法)
代码:
/**
* 单例-懒汉-同步方法 线程安全
*/
public class SingletonThreadSafeSync1 {
//静态成员变量
private static SingletonThreadSafeSync1 instance;
//私有化构造方法
private SingletonThreadSafeSync1() {
}
//提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
public static synchronized SingletonThreadSafeSync1 getInstance() {
if (instance == null) {
instance = new SingletonThreadSafeSync1();
}
return instance;
}
}
测试:
class SingletonThreadSafeSync1Test {
@Test
void getInstance() {
System.out.println("懒汉式 2 , 线程安全~");
SingletonThreadSafeSync1 s1 = SingletonThreadSafeSync1.getInstance();
SingletonThreadSafeSync1 s2 = SingletonThreadSafeSync1.getInstance();
System.out.println(s1 == s2); // true
System.out.println("instance.hashCode=" + s1.hashCode());
System.out.println("instance2.hashCode=" + s2.hashCode());
}
}
说明:
- 解决了 线程安全问题.
- 效率太低了,每个线程在想获得类的实例时候,执行 getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了,后面的想获得该类实例,直接 return 就行了。 方法进行同步效率太低.
- 结论:在实际开发中, 不推荐使用这种方式.
3. 懒汉式(线程安全,同步代码块)
代码:
/**
* 单例-懒汉-同步代码块 线程安全
* 效率低不推荐使用
*/
public class SingletonThreadSafeSync2 {
//静态成员变量
private static SingletonThreadSafeSync2 instance;
//私有化构造方法
private SingletonThreadSafeSync2() {
}
//提供一个静态的公有方法,加入同步处理的代码,解决线程安全问题
public static SingletonThreadSafeSync2 getInstance(){
//不推荐,每次都会进入同步代码块,很影响效率
synchronized (SingletonThreadSafeSync2.class){
if (instance == null) {
instance = new SingletonThreadSafeSync2();
}
}
return instance;
}
}
测试同上,效果同上,解决了线程安全问题, 但效率低,不推荐.
4. 双重检查(推荐)
代码:
/**
* 双重检查
*/
public class DoubleCheck {
// 注意加上volatile 关键字,防止指令重排
private static volatile DoubleCheck instance;
//私有化构造方法
private DoubleCheck() {
}
//提供一个静态的公有方法,加入双重检查代码,解决线程安全问题, 同时解决懒加载问题
//同时保证了效率, 推荐使用
public static DoubleCheck getInstance() {
if (instance == null) {
synchronized (DoubleCheck.class) {
if (instance == null) {
//下面这句代码其实分为三步:
//1.开辟内存分配给这个对象
//2.初始化对象
//3.将内存地址赋给虚拟机栈内存中的doubleLock变量
//注意上面这三步,第2步和第3步的顺序是随机的,这是计算机指令重排序的问题
//假设有两个线程,其中一个线程执行下面这行代码,如果第三步先执行了,就会把没有初始化的内存赋值给doubleLock
//然后恰好这时候有另一个线程执行了第一个判断if(doubleLock == null),然后就会发现doubleLock指向了一个内存地址
//这另一个线程就直接返回了这个没有初始化的内存,所以要防止第2步和第3步重排序
// 所以要加上加上volatile关键字,防止指令重排
instance = new DoubleCheck();
}
}
}
return instance;
}
}
测试:
class DoubleCheckTest {
@Test
void getInstance() {
System.out.println("双重检查");
DoubleCheck s1 = DoubleCheck.getInstance();
DoubleCheck s2 = DoubleCheck.getInstance();
System.out.println(s1 == s2); // true
System.out.println("instance.hashCode=" + s1.hashCode());
System.out.println("instance2.hashCode=" + s2.hashCode());
}
}
说明:
- Double-Check 概念是多线程开发中常使用到的,如代码中所示,我们进行了两次
if (singleton == null)
检查,这样就可以保证线程安全了。 - 实例化代码只用执行一次,后面再次访问时,判断
if (singleton == null)
,直接 return 实例化对象,也避免的反复进行方法同步 - 线程安全; 延迟加载; 效率较高
- 结论:在实际开发中, 推荐使用这种单例设计模式
5. 静态内部类(推荐)
代码:
/**
* 静态内部类实现单例, 推荐使用
*/
public class StaticInnerClass {
// 防止指令重排
private static volatile StaticInnerClass instance;
//构造器私有化
private StaticInnerClass() {}
//写一个静态内部类,该类中有一个静态属性 Singleton
//加载一个类时,其内部类不会同时被加载,利用内部类的这个特性来实现单例
private static class SingletonInstance {
private static final StaticInnerClass INSTANCE = new StaticInnerClass();
}
//提供一个静态的公有方法,直接返回 SingletonInstance.INSTANCE
public static synchronized StaticInnerClass getInstance() {
return SingletonInstance.INSTANCE;
}
Runtime a = Runtime.getRuntime();
}
测试:
class StaticInnerClassTest {
@Test
void getInstance() {
System.out.println("使用静态内部类完成单例模式");
StaticInnerClass instance = StaticInnerClass.getInstance();
StaticInnerClass instance2 = StaticInnerClass.getInstance();
System.out.println(instance == instance2); // true
System.out.println("instance.hashCode=" + instance.hashCode());
System.out.println("instance2.hashCode=" + instance2.hashCode());
}
}
说明:
- 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
- 静态内部类方式在 Singleton 类被装载时并不会立即实例化,而是在需要实例化时,调用 getInstance 方法,才会装载 SingletonInstance 类,从而完成 Singleton 的实例化。 可参见 这里
- 类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM 帮助我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。
- 优点: 避免了线程不安全,利用 静态内部类特点实现延迟加载,效率高
- 结论: 推荐使用
6. 枚举
- 这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建
新的对象。 - 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式
- 结论: 推荐使用