Java并发编程中的设计模式解析(二)一个单例的七种写法

Java单例模式是最常见的设计模式之一，广泛应用于各种框架、中间件和应用开发中。单例模式实现起来比较简单，基本是每个Java工程师都能信手拈来的，本文将结合多线程、类的加载等知识，系统地介绍一下单例模式的演变，并体现在7种不同的单例设计中。说到这个，非常像孔乙己里那个“回字有四种写法”的梗，不过与封建迂腐文人不同的是，从简单的单例设计变化，可以看到一个需求演变的过程，看到一个方法不断完善的过程。

传送门：Java并发编程中的设计模式解析(一)

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;
     }
 }

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();
     }
 }