单例模式

模式动机

对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID（序号）生成器。

如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。

一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。

模式定义

单例模式(Singleton Pattern)：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。

单例模式

模式结构

单例模式包含如下角色：

• Singleton：单例

实现方法

单例模式实现方法常见的有懒汉式加载和饿汉式加载

• 懒汉式：实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，如果有则返回，没有则新建。

• 饿汉式：实例在初始化的时候就创建好了，用的时候直接取就可以了

实现代码

（1）饿汉式方法

/**
 * 饿汉式单例模式
 * 优点：类加载到内存后，就实例化一个单例，JVM保证线程安全，简单实用，推荐使用！
 * 缺点：不管用到与否，类加载的时候就会完成实列化
 * @author code_yc
 * @version 1.0
 * @date 2020/6/28 7:29
 */
public class Mgr01 {

    // final关键定义了属性在类加载的时候就进行初始化
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {
    }

    public static Mgr01 getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) {
        Mgr01 m1 = getInstance();
        Mgr01 m2 = getInstance();
        System.out.println(m1 == m2);
    }
}

（2）一种不优雅的懒汉式加载

/**
 * 一种不优雅的懒汉式加载
 * 使用synchronized对getInstance()方法进行加锁，保证了线程安全，但是带来了效率的下降
 * @author code_yc
 * @version 1.0
 * @date 2020/6/28 7:46
 */
public class Mgr03 {

    private static Mgr03 INSTANCE;

    private Mgr03() {
    }

    public static synchronized Mgr03 getInstance() {
        if(INSTANCE == null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() ->{
                System.out.println(Mgr03.getInstance().hashCode());
            }).start();
        }
    }
}

• 缺点：可以看到任何时候，任何线程想要获取实例的时候，都会进入getInstance()方法，从而实现单例的获取，但是造成了每次获取对象都面临着加锁的过程，效率不高

（3）双重锁检验实现懒汉式加载

/**
 * 双重锁检查实现单例模式
 * @author code_yc
 * @version 1.0
 * @date 2020/6/28 7:54
 */
public class Mgr05 {

    // volatile防止指令重排，造成返回还没有初始化的实例对象
    private static volatile Mgr05 INSTANCE;

    private Mgr05() {
    }

    public static Mgr05 getInstance() {
        if(INSTANCE == null){
            synchronized (Mgr05.class){
                // 双重检查
                if(INSTANCE == null){
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr05();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() ->{
                System.out.println(Mgr05.getInstance().hashCode());
            }).start();
        }
    }
}

• 注意： 这里的INSTANCE属性一定要用voliatle修饰，为了避免指令重排，导致载执行getInstance()方法的时候，分配内存结束之后，先进性了对象的复制返回，然后再进行对象的初始化，这样就导致实际返回的单例是一个空对象

（4）静态内部类的方式实现懒汉式加载

VM保证线程安全，加载外部类的时候不会加载内部类，所以只有调用geyInstance()方法的时候，内部类才会加载

public class Mgr06 {

    private Mgr06() { }

    private static class Mgr06Holder {
        private final static Mgr06 INSTANCE = new Mgr06();
    }

    public static Mgr06 getInstance() {
        return Mgr06Holder.INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() ->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

（5）枚举单例

/**
 * 枚举单例
 * @author code_yc
 * @version 1.0
 * @date 2020/6/28 8:04
 */
public enum Mgr07 {

    INSTANCE;

    public void m() {
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Mgr07.INSTANCE.hashCode());
            }).start();
        }
    }
}

• 枚举单例优点：枚举类是没有构造方法的，所以没办法透过反射来创建对象，所以说枚举也是一种绝对的单例