详聊单例模式

1、安全发布对象

 
发布对象：使一个对象能够被当前范围之外的代码所使用。

对象逸出：一种错误的发布。当一个对象还没有构造完成时，就使它被其他线程所见。

 

安全发布对象的4种方法：

• 在静态初始化函数中初始化一个对象引用。
• 将对象的引用保存到 volatile 类型域 或者 AtomicReference 对象中。
• 将对象的引用保存到某个正确构造对象的final类型域中。
• 将对象的引用保存到一个由锁保护的域中。

 

2、七种单例模式的写法

 

2.1 普通的懒汉模式

 

/**
 * @author
 * @title: SingletonEx1
 * @description: 单例-懒汉模式-线程不安全
 * @date 2020/4/11 15:16
 */
public class SingletonEx1 {

    // 私有的构造函数
    private SingletonEx1() {
        // todo ……
    }

    // 单例对象
    private static  SingletonEx1 instance = null;

    // 静态的工厂方法
    public static SingletonEx1 getInstance () {
         if (instance == null)  // 多线程同时调用，这一步可能会出现问题
             instance = new SingletonEx1();
        return instance;
    }

}

 

2.2 普通的饿汉模式

 

/**
 * @author
 * @title: SingletonEx2
 * @description: 单例-饿汉模式-线程安全
 * @date 2020/4/11 15:35
 */
public class SingletonEx2 {

    // 私有的构造函数
    private SingletonEx2() {
        // todo ……
    }
    // 单例对象
    private static SingletonEx2 instance =
                             new SingletonEx2();

    public static SingletonEx2 getInstance() {
        return instance;
    }

}

 

2.3 线程安全的懒汉模式

 

/**
 * @author
 * @title: SingletonEx3
 * @description: 单例-懒汉模式-线程安全-效率低
 *               不推荐使用该写法，性能开销大
 * @date 2020/4/11 15:37
 */
public class SingletonEx3 {
    // 私有的构造函数
    private SingletonEx3 () {
        // todo ……
    }
    // 单例对象
    private static SingletonEx3 instance = null;

    public static synchronized SingletonEx3 getInstance() {
        if (instance == null)
            instance = new SingletonEx3();
        return instance;
    }

}

 

2.4 双重同步锁单例模式

 

/**
 * @author 
 * @title: SingletouEx4
 * @description: 单例-懒汉模式改造-双重同步锁单例模式-线程不安全-双重检测机制
 *               多线程情况下，可能会由于JVM和CPU优化,导致指令重排，从而不安全。
 * @date 2020/4/11 15:40
 */
public class SingletonEx4 {
    // 私有的构造函数
    private SingletonEx4 () {
        // todo ……
    }
    // 单例对象
    private static SingletonEx4 instance = null;

    public static SingletonEx4 getInstance() {
        if (instance == null) { // 双重检测机制    B
            synchronized (SingletonEx4.class) { // 加锁
                if (instance == null)  // 双重检测机制
                    instance = new SingletonEx4();  // A-3
            }
        }
        return instance;
    }

    /**
     * 该写法线程不安全原因分析
     * 在CPU 执行实例化 new SingletonEx4(); 的过程中，CPU 的指令顺序为：
     *    1、memory = allocate() 分配对象的内存空间。
     *    2、ctorInstance() 初始化对象。
     *    3、instance = memory 设置 instance 指向刚分配的内存。
     *
     *  单线程情况下，按以上指令顺序是没有问题的，
     *  在多线程情况下，JVM和CPU优化，可能会出现指令重排
     *
     *  出现以下顺序：
     *  1、memory = allocate() 分配对象的内存空间。
     *  3、instance = memory 设置 instance 指向刚分配的内存。
     *  2、ctorInstance() 初始化对象。
     *
     *  假设现在有两个线程 A 和 B
     *
     *  现在 线程A走到程序第 21 行 cpu执行第3指令,
     *  同时，线程B走到程序第 18 行，会判断 instance != null ,直接返回 instance.
     *  而实际上 cpu 还没有执行 《ctorInstance() 初始化对象。》指令
     *  从而，出现线程不安全的情况。
     *
     */


}

 

2.5 volatile + 双重同步锁单例模式

 

/**
 * @author 
 * @title: SingletonEx5
 * @description: 单例-懒汉模式-线程安全
 * @date 2020/4/11 15:44
 */
public class SingletonEx5 {
    // 私有的构造函数
    private SingletonEx5 () {
        // todo ……
    }

    // volatile 能杜绝指令重排，用于双重检测时，能保证线程安全
    private static volatile SingletonEx5 instance = null;

    public static SingletonEx5 getInstance() {
        if (instance == null) {
            synchronized (SingletonEx5.class) {
                if (instance == null)
                    instance = new SingletonEx5();
            }
        }
        return instance;
    }

}

 

2.6 静态代码块的饿汉模式

 

/**
 * @author 
 * @title: SingletonEx6
 * @description: 单例-饿汉模式-线程安全
 * @date 2020/4/11 15:47
 */
public class SingletonEx6 {
    // 私有的构造函数
    private SingletonEx6 () {
        // todo ……
    }

    // 注意static 关键修饰的代码块和函数，按顺序执行。
    static {
        instance = new SingletonEx6();
    }
    // 单例对象
    private static SingletonEx6 instance = null;

    public static SingletonEx6 getInstance() {
        return instance;
    }

}

 

2.7 枚举模式单例（推荐写法）

 

/**
 * @author 
 * @title: SingletonEx7
 * @description: 单例-枚举模式-线程安全-推荐使用该写法-效率高
 *               比懒汉模式安全，比饿汉模式效率高
 * @date 2020/4/11 15:51
 */
public class SingletonEx7 {

    // 私有构造函数
    private SingletonEx7 () {
        // todo ……
    }

    public static SingletonEx7 getInstance() {
        return Singleton.INSTANCE.getInstance();
    }

    private enum Singleton {

        INSTANCE;

        private SingletonEx7 instance;

        // JVM 保证这个方法绝对只调用一次
        Singleton () {
              instance = new SingletonEx7();
        }

        public SingletonEx7 getInstance() {
            return instance;
        }
    }



}