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