单例设计模式

介绍

意图： 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决： 一个全局使用的类频繁地创建与销毁。

何时使用： 当您想控制实例数目，节省系统资源的时候。

如何解决： 判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码： 构造函数是私有的。

实现类图

实现方式

懒汉模式+DCL+线程安全+防止指令重排序

特点：线程安全，在多线程情况下保持高性能。

1. DCL（Double Check Lock）双重检查锁，加锁优化，保证性能

2. synchronized保证线程安全

3. volatile可以防止编译器（JIT）、CPU对指令的重排序，导致使用还没有被初始化的实例。

   instance = new SingletonObject()这行代码在字节码层面由三个指令完成：

   1. 分配内存空间
   2. 初始化
   3. 引用赋值

   如果不加volatile，可能会重排序为

   1. 分配内存空间

   2. 引用赋值

      如果在第一步指令执行完，有其他线程来获取实例，将会拿到未初始化的实例。

   3. 初始化

public class SingletonObject {

    private volatile static SingletonObject instance;

    private SingletonObject() {}

    public static SingletonObject getInstance(){
        //先判断一次对象是否已经实例化，不要一进来就加锁，影响性能
        if(instance == null){
            //如果有A、B两个线程同时走到这里，A线程拿到锁，B线程在此等待
            synchronized (SingletonObject.class){
                //A线程实例化完之后，释放锁，B线程拿到锁，进入同步代码块，这里需要再检查一次对象是否已经被实例化
                if(instance==null){
                    instance = new SingletonObject();
                }
            }
        }
        return instance;
    }
}

恶汉模式

在类加载的初始化阶段就完成了实例的初始化，利用了类加载原理，保证实例的唯一（类加载的初始化过程只会执行一次）和线程安全（JVM同步完成类加载的全部过程）。

只有在真正使用到类的时候，才会触发类加载的初始化，比如当前类是启动类、new操作、访问静态属性、访问静态方法、反射访问类、初始化一个类的子类等。

优点：简单粗暴，无锁，执行效率更高

缺点：容易产生垃圾对象，在类加载的初始化阶段就完成了实例的初始化，浪费内存。

public class HungrySingleton {

    private static HungrySingleton instance = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return instance;
    }
}

静态内部类

同样利用类加载机制保证线程安全，懒加载，只有主动调用SingletonHolder内部类才会实例化instance。

public class InnerClassSingleton {

    public static InnerClassSingleton getInstance(){
        return SingletonHolder.instance;
    }

    private InnerClassSingleton() {
        //防止反射破坏单例类
        if(SingletonHolder.instance != null){
            throw new RuntimeException("此类是单例类");
        }
    }

    private static class SingletonHolder {
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }
}

反射攻击

public static void main(String[] args) throws Exception {
    InnerClassSingleton singleton = InnerClassSingleton.getInstance();

    Constructor<InnerClassSingleton> declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();
    declaredConstructor.setAccessible(true);
    InnerClassSingleton reflectSingleton = declaredConstructor.newInstance();
    //结果：false
    System.out.println(singleton == reflectSingleton);
}

枚举

简单，不支持反射，利用类加载机制保证线程安全

自动支持序列化机制，防止反序列化时创建新的实例。需要序列化创建对象时，可使用此种方法。

public enum EnumSingleton {

    INSTANCE;

    public void hello(){
        System.out.println("hello");
    }
}

 class Test{
     public static void main(String[] args) throws IOException {
        EnumSingleton instance=EnumSingleton.INSTANCE;
        EnumSingleton instance1=EnumSingleton.INSTANCE;
         //结果：true
        System.out.println(instance==instance1);

        try(ObjectOutputStream oos=new ObjectOutputStream( new FileOutputStream( "EnumSingleton" ) )) {
            oos.writeObject( instance );
        }

        try (ObjectInputStream ois=new ObjectInputStream( new FileInputStream( "EnumSingleton" ) )){
            EnumSingleton object=((EnumSingleton) ois.readObject());
            //结果：true
            System.out.println(object==instance);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } 
    }
 }