Java单例模式是最常见的设计模式之一，广泛应用于各种框架、中间件和应用开发中。单例模式实现起来比较简单，基本是每个Java工程师都能信手拈来的，本文将结合多线程、类的加载等知识，系统地介绍一下单例模式的演变，并体现在7种不同的单例设计中。说到这个，非常像孔乙己里那个“回字有四种写法”的梗，不过与封建迂腐文人不同的是，从简单的单例设计变化，可以看到一个需求演变的过程，看到一个方法不断完善的过程。
1. 饿汉式
最简单的单例设计，优点是线程安全，但是因为类加载即初始化实例，加入实例变量比较多的话，会占用较多的内存。
//不允许被继承
public final class SingletonStarve {
//实例变量, 由于单例对象是静态的, 在类的加载阶段, 就会初始化实例变量
@SuppressWarnings("unused")
private byte[] data = new byte[1024];
//定义静态实例对象的时候直接初始化
private static SingletonStarve instance = new SingletonStarve();
//私有化构造函数, 不允许直接new对象
private SingletonStarve() {}
//提供公共的方法获取实例对象
public static SingletonStarve getInstance() {
return instance;
}
}
2. 懒汉式
实现了单例设计的懒加载，节省了前期内存空间的占用，但是在多线程环境下可能会导致多对象的产生，破坏实例唯一性。
//不允许被继承
public final class LazySingleton {
//实例变量, 由于单例对象是静态的, 在类的加载阶段, 就会初始化实例变量
@SuppressWarnings("unused")
private byte[] data = new byte[1024];
//定义静态实例对象, 不直接初始化
private static LazySingleton instance = null;
//私有化构造函数, 不允许直接new对象
private LazySingleton() {}
//提供公共的方法获取实例对象
public static LazySingleton getInstance() {
if(null == instance) {
instance = new LazySingleton();
}
return instance;
}
}
3. 懒汉式+同步锁
通过使用synchronized关键字使getInstance方法变为同步方法，从而确保线程安全，但带来了一定的性能问题。
//不允许被继承
public final class SyncLazySingleton {
//实例变量, 由于单例对象是静态的, 在类的加载阶段, 就会初始化实例变量
@SuppressWarnings("unused")
private byte[] data = new byte[1024];
//定义静态实例对象, 不直接初始化
private static SyncLazySingleton instance = null;
//私有化构造函数, 不允许直接new对象
private SyncLazySingleton() {}
//提供公共的方法获取实例对象, 通过synchronized修饰为同步方法
public static synchronized SyncLazySingleton getInstance() {
if(null == instance) {
instance = new SyncLazySingleton();
}
return instance;
}
}
4. Double-Check
推荐使用：Double-Check单例模式，通过两次非空判断，并且对第二次判断加锁，确保了多线程下的单例设计安全，同时保证了性能。
注意：Double-check有可能因为JVM指令重排的原因，导致空指针异常；使用volatile修饰对象引用，可以确保其可见性，避免异常
//不允许被继承
public final class VolatileDoubleCheckSingleton {
//实例变量, 由于单例对象是静态的, 在类的加载阶段, 就会初始化实例变量
@SuppressWarnings("unused")
private byte[] data = new byte[1024];
//定义静态实例对象, 不直接初始化
//通过volatile, 避免指令重排序导致的空指针异常
private static volatile VolatileDoubleCheckSingleton instance = null;
Connection conn;
Socket socket;
//私有化构造函数, 不允许直接new对象
//由于指令重排序, 实例化顺序可能重排, 从而导致空指针,使用volatile关键字修饰单例解决
private VolatileDoubleCheckSingleton() {
//this.conn;
//this.socket;
}
//提供公共的方法获取实例对象
public static VolatileDoubleCheckSingleton getInstance() {
if(null == instance) {
synchronized(VolatileDoubleCheckSingleton.class) {
if(null == instance) {//以下赋值因为不是原子性的，如果不使用volatile使instance在多个线程中可见，将可能导致空指针
instance = new VolatileDoubleCheckSingleton();
}
}
}
return instance;
}
}
5. 静态内部类
推荐使用：通过使用静态内部类，巧妙地避免了线程不安全，并且节省了前期内存空间，编码非常简洁。
//不允许被继承
public final class HolderSingleton {
//实例变量
@SuppressWarnings("unused")
private byte[] data = new byte[1024];
//私有化构造器
private HolderSingleton() {}
//定义静态内部类Holder, 及内部实例成员, 并直接初始化
private static class Holder{
private static HolderSingleton instance = new HolderSingleton();
}
//通过Holder.instance获得单例
public static HolderSingleton getInstance() {
return Holder.instance;
}
}
<!–
p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 12.0px Menlo; color: #4e9072}
p.p2 {margin: 0.0px 0.0px 0.0px 0.0px; font: 12.0px Menlo}
p.p3 {margin: 0.0px 0.0px 0.0px 0.0px; font: 12.0px Menlo; color: #777777}
p.p4 {margin: 0.0px 0.0px 0.0px 0.0px; font: 12.0px Menlo; color: #931a68}
span.s1 {color: #931a68}
span.s2 {color: #000000}
span.s3 {color: #3933ff}
span.s4 {color: #0326cc}
span.Apple-tab-span {white-space:pre}
–>
6. 枚举类
《Effective Java》中推荐的单例设计模式，缺点是饿汉式，并且对编码能力要求较高。
//枚举本身是final的, 不允许被继承
public enum EnumSingleton {
INSTANCE;
//实例变量
@SuppressWarnings("unused")
private byte[] data = new byte[1024]; EnumSingleton() {
System.out.println("INSTANCE will be initialized immediately");
}
public static void method() {
//调用该方法会主动使用EnumSingleton, INSTANCE将会实例化
}
public static EnumSingleton getInstance() {
return INSTANCE;
}
}
7. 内部枚举类
/*
* 使用枚举类作为内部类实现懒加载
*/
public final class LazyEnumSingleton {
private LazyEnumSingleton(){}
private enum EnumHolder{
INSTANCE;
private LazyEnumSingleton instance;
EnumHolder(){
this.instance = new LazyEnumSingleton();
}
private LazyEnumSingleton getLazyEnumSingleton() {
return instance;
}
}
public static LazyEnumSingleton getInstance() {
return EnumHolder.INSTANCE.getLazyEnumSingleton();
}
}
