5. 单例模式

1. 饿汉式

package com.zhang.singleton;

import java.io.Serializable;

public class Singleton1 implements Serializable {
    /**饿汉式创建单例：在类被加载链接初始化时，实例已经被创建
     * 1.私有化构造方法Singleton1(){}
     * 2.定义一个私有的Singleton1的成员变量
     * 3.提供静态公共的返回该变量的方法
      
     饿汉式创建单例时需要注意的一些问题：
     * 1.反射可以破坏单例，可以在类的私有构造里先判断私有的实例变量是否为空，不为空抛出异常
        if (INSTANCE != null) {
            throw new RuntimeException("单例对象不能重复创建");
        }
     * 2.类实现序列化接口，`readResolve()` 是止反序列化破坏单例
     public Object readResolve() {
        return INSTANCE;
     }
     * 3.Unsafe 破坏单例，没有办法解决
     */


    //1.私有构造
    private Singleton1(){
        System.out.println("private Singleton1()");
    }

    //2.私有静态实例变量
    private static  final  Singleton1  INSTANCE    = new Singleton1();

    //3.提供获取该单例的方法
    public static Singleton1 getInstance(){
        return INSTANCE;
    }
}

2. 枚举饿汉式

package com.zhang.singleton;

/**
 *  2. 枚举饿汉式:枚举类可以控制枚举类的对象个数,
 *  枚举饿汉式可以天然防止反射和序列化破坏单例，但是防止不住unsafe破坏单例
 */
public enum Singleton2 {
    INSTANCE;

    //1.私有构造
    private Singleton2() {
        System.out.println("private Singleton2()");
    }
    

    @Override
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

}

3. 懒汉式

package com.zhang.singleton;

/**
 *  2. 懒汉式创建单例，
 */
public class Singleton3 {

    //1.私有构造
    private Singleton3() {
        System.out.println("private Singleton3()");
    }


    //2.定义实例变量，但不new
    private static  Singleton3 INSTANCE;


    //3.提供获取实例的方法
    public static synchronized Singleton3 getInstance() {
        /**
         *  如果在多线程环境下，假如线程1抢到CPU执行权进来发现INSTANCE为null，
         *   在创建对象准备赋值时CPU执行权被线程2抢走了，这时INSTANCE还没被线程1成功赋值也为null
         *   这样就会创建了俩次对象，就会破坏单例；
         *   可以在静态方法加synchronized锁对线程保护
         */

        if(INSTANCE == null){
            INSTANCE = new Singleton3();

        }
        return INSTANCE;
    }

}

• 其实只有首次创建单例对象时才需要同步，但该代码实际上每次调用都会同步
• 因此有了下面的双检锁改进

4. 双检锁式懒汉式

package com.zhang.singleton;

/**
 *  2. 懒汉式创建单例，双检锁
 */
public class Singleton4 {

    //1.私有构造
    private Singleton4() {
        System.out.println("private Singleton4()");
    }


    //2.定义实例变量，但不赋值
    /**
     * 为何必须加 volatile：
     * * `INSTANCE = new Singleton4()` 不是原子的，
     * 分成 3 步：创建对象、调用构造、给静态变量赋值，其中后两步可能被指令重排序优化，变成先赋值、再调用构造
     * * 如果线程1 先执行了赋值，线程2 执行到第一个 `INSTANCE == null` 时发现 INSTANCE 已经不为 null，此时就会返回一个未完全构造的对象
     */
    private static volatile Singleton4 INSTANCE;


    //3.提供获取实例的方法
    public static  Singleton4 getInstance() {

        if(INSTANCE == null){
            synchronized (Singleton4.class){
                if(INSTANCE == null){
                    INSTANCE = new Singleton4();
                }
            }
        }

        return INSTANCE;
    }

}

5. 内部类懒汉式

package com.zhang.singleton;

/**
 *  2. 懒汉式内部类创建单例,避免了双检锁的缺点
 */
public class Singleton5 {

    //1.私有构造
    private Singleton5() {
        System.out.println("private Singleton5()");
    }


    //2.静态内部类
    private static class In{
        private static  Singleton5 INSTANCE = new Singleton5();
    }


    //3.提供获取实例的方法
    public static Singleton5 getInstance() {
        return In.INSTANCE;
    }

}

JDK 中单例的体现

• Runtime 体现了饿汉式单例
• Console 体现了双检锁懒汉式单例
• Collections 中的 EmptyNavigableSet 内部类懒汉式单例
• ReverseComparator.REVERSE_ORDER 内部类懒汉式单例
• Comparators.NaturalOrderComparator.INSTANCE 枚举饿汉式单例