设计模式之单例模式

一、介绍

　　单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

TIPS:
    1、单例类只能有一个实例。
    2、单例类必须自己创建自己的唯一实例。
    3、单例类必须给所有其他对象提供这一实例。

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

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

核心思想：构造函数是私有的。并且对外提供一个全局的访问方法。

使用场景：　

1、要求生产唯一序列号。
2、代码级别的全局的JVM缓存。（有状态的单例）
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

二、懒汉式

　　所谓的懒汉式单例，是指：第一次调用才初始化，避免内存浪费。典型的时间换取空间的做法。因为第一次获取单例的时候会执行单例的实例化，浪费一些时间。但是后面再继续获取就不存时间问题了。

2.1、懒汉式的简化版

package com.shf.mode.singleton;

/**
 * 描述：懒汉式
 * 单例实例在第一次调用的时候创建
 * 典型的以时间换取空间，第一次调用 getInstance()才会实例化单例。
 *
 * @Author shf
 * @Date 2019/7/15 16:12
 * @Version V1.0
 **/
public class SingletonExample2 {
    // 私有构造方法，禁止外部直接创建实例
    private SingletonExample2(){}
    // 私有 单例对象 将对象的管理权封闭
    private static SingletonExample2 instance = null;

    // 静态的工厂方法
    public static SingletonExample2 getInstance(){
        if(instance == null){
            instance = new SingletonExample2();
        }
        return instance;
    }
}

　　ok，我们看一下这种最简单的懒汉式存在的问题。

　　在多线程环境下，当两个线程同时访问这个方法，同时制定到instance==null的判断。都判断为null，接下来同时执行new操作。这样类的构造函数被执行了两次。一旦构造函数中涉及到某些资源的处理，那么就会发生错误。所以说最简式是线程不安全的。

2.2、懒汉式 synchronized版

public class SingletonExample2 {
    // 私有构造方法，禁止外部直接创建实例
    private SingletonExample2(){}
    // 私有 单例对象 将对象的管理权封闭
    private static SingletonExample2 instance = null;

    // 静态的工厂方法
    public synchronized static SingletonExample2 getInstance(){
        if(instance == null){
            instance = new SingletonExample2();
        }
        return instance;
    }
}

　　如上代码所示，我们采用synchronized修饰getInstance()方法。有效的解决了线程安全性的问题，但是，，，但是synchronized直接锁死了getInstance()方法，意味着在多线程环境下getInstance()方法的并发效率会大大降低，性能损耗十分严重，因为getInstance()方法已经成为了一个同步方法。

2.3、懒汉式的双重检测机制

public class SingletonExample2 {
    // 私有构造方法，禁止外部直接创建实例
    private SingletonExample2(){}
    // 私有 单例对象 将对象的管理权封闭
    private static SingletonExample2 instance = null;

    // 静态的工厂方法
    public static SingletonExample2 getInstance(){
        if(instance == null){// 双重监测机制
            synchronized(SingletonExample2.class){// 同步锁
                if(instance == null){
                    instance = new SingletonExample2();
                }
            }
        }
        return instance;
    }
}

　　双重检测机制保证了 synchronized 代码块中代码的线程安全性，另外当已经初始化完成了单例后调用 getInstance()方法，不会再次进入synchronized 代码块中，貌似是满足了线程安全性和性能的提升。但是，，，真的是线程安全的吗？NO，因为 instance = new SingletonExample2(); 该行代码会发生指令重排。

　　在上述代码中，执行new操作的时候，CPU一共进行了三次指令 

1，memory = allocate() 分配对象的内存空间 
2，ctorInstance() 初始化对象 
3，instance = memory 设置instance指向刚分配的内存

　　在程序运行过程中，CPU在不违背 happens-before 八大原则的前提下，为提高运算速度会做出违背代码原有顺序的优化。我们称之为乱序执行优化或者说是指令重排。那么上面知识点中的三步指令极有可能被优化为1，3，2的顺序。当我们有两个线程A与B，A线程遵从132的顺序，经过了两此instance的空值判断后，执行了new操作，并且cpu在某一瞬间刚结束指令3，并且还没有执行指令2。而在此时线程B恰巧在进行第一次的instance空值判断，由于线程A执行完3指令，为instance分配了内存，线程B判断instance不为空，直接执行return，返回了instance，这样就出现了错误。

2.4、懒汉式终极版：双重检测机制+volatile禁止指令重排

package com.shf.mode.singleton;

/**
 * 描述：懒汉式
 * 单例实例在第一次调用的时候创建
 * 典型的以时间换取空间，第一次调用 getInstance()才会实例化单例。
 *
 * @Author shf
 * @Date 2019/7/15 16:12
 * @Version V1.0
 **/
public class SingletonExample2 {
    // 私有构造方法，禁止外部直接创建实例
    private SingletonExample2(){}
    // 1、memory = allocate() 分配对象的内存空间
    // 2、ctorInstance() 初始化对象
    // 3、instance = memory 设置instance指向刚分配的内存

    // 单例对象 volatile + 双重检测机制 -> 禁止指令重排
    // 私有 单例对象 将对象的管理权封闭
    private volatile static SingletonExample2 instance = null;

    // 静态的工厂方法
    public static SingletonExample2 getInstance(){
        if(instance == null){// 双重监测机制
            synchronized(SingletonExample2.class){// 同步锁
                if(instance == null){
                    instance = new SingletonExample2();
                }
            }
        }
        return instance;
    }
}

　　关于happens-before原则和volatile禁止指令重排感兴趣的可以度娘一下。或者参考一下这篇博客。

　　双重检测机制又称双重校验锁（DCL，即 double-checked locking）。面试官很中意这个玩意哦。

三、饿汉式

　　所谓饿汉式就是不管你用不用，我都先给你创建出来。空间换时间，但是毕竟如果不用的话岂不是白白浪费了空间，如果保证这个单例一定会被调用，饿汉式也是一个不错的选择，而且实现的难度相对于懒汉式也简单不少。

package com.shf.mode.singleton;

/**
 * 描述：饿汉式
 * 单例实例在类装载时创建
 * 典型的用空间换取时间----不管用不用都先创建出来
 *
 * @Author shf
 * @Date 2019/7/15 15:58
 * @Version V1.0
 **/
public class SingletonExample1 {
    // 私有构造方法，禁止外部直接创建实例
    private SingletonExample1(){}
    // 私有 单例对象 将对象的管理权封闭
    private static SingletonExample1 instance = null;
    // 静态方法块 完成单例的实例化
    static {
        instance = new SingletonExample1();
    }
    // public 对外开发的获取单例的唯一渠道
    public SingletonExample1 getInstance(){
        return instance;
    }
}

　　

TIPS:
        静态域和静态代码块的顺序不要乱了哦，静态域与静态块是按照顺序执行的。这是Java基础知识的内容，就不过多解释了。

四、枚举式

　　这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化，这个是JVM保证的。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。

package com.shf.mode.singleton;

/**
 * 描述：
 *
 * @Author shf
 * @Date 2019/7/16 0:28
 * @Version V1.0
 **/
public class SingletonExample3 {
    // 私有构造方法，禁止外部直接创建实例
    private SingletonExample3() {}

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

    private enum Singleton {
        INSTANCE;
        private SingletonExample3 singleton;

        Singleton() {
            singleton = new SingletonExample3();
        }

        public SingletonExample3 getInstance() {
            return singleton;
        }
    }
}

　　

　　如有错误的地方还请留言指正。

　　原创不易，转载请注明原文地址：https://www.cnblogs.com/hello-shf/p/11192500.html