设计模式 ☞ 创建型模式之单例模式-CSDN博客

本文链接：https://blog.csdn.net/Demo_Null/article/details/111550320

1.1 简介

1.1.1 概述

单例(Singleton)模式的定义：是一种创建型设计模式，让你能够保证一个类只有一个实例，并提供一个访问该实例的全局节点。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。单例模式在现实生活中的应用也非常广泛，例如，早上进公司一看，呵！这不是部门经理嘛，还是那个味，还是昨天那个人，妥妥的单例。

在这里插入图片描述

1.1.2 优缺点

单例模式的优点：
① 单例模式可以保证内存里只有一个实例，减少了内存的开销。
② 可以避免对资源的多重占用。
③ 单例模式设置全局访问点，可以优化和共享资源的访问。

单例模式的缺点：
① 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
② 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
③ 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

1.2 实现方式

1.2.1 饿汉式（静态常量）

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2020/12/23
 */
public class Singleton {

    /**
     * 私有构造方法
     */
    private Singleton() {};

    /**
     * 创建实例
     */
    private static final Singleton INSTANCE = new Singleton();

    /**
     * 获取实例
     * @return Singleton
     */
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法时装载，但是导致类装载的原因有很多种，因此不能确定有其他的方式导致类装载，这时候初始化 instance 就没有达到懒加载的效果，可能导致内存浪费。

1.2.2 饿汉式（静态代码块）

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2020/12/23
 */
public class Singleton {

    /**
     * 私有构造方法
     */
    private Singleton() {};

    /**
     * 创建内部对象
     */
    private static Singleton instance;


    /**
     * 在静态代码块中创建实例
     */
    static {
        instance = new Singleton();
    }

    /**
     * 获取实例
     * @return Singleton
     */
    public static Singleton getInstance() {
        return instance;
    }
}

这种方式和第一种使用静态常量的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。

1.2.3 懒汉式（线程不安全）

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2020/12/23
 */
public class Singleton {

    /**
     * 私有构造方法
     */
    private Singleton() {};

    /**
     * 创建内部对象
     */
    private static Singleton instance;

    /**
     * 获取实例
     * @return Singleton
     */
    public static Singleton getInstance() {
        if (null == instance) {
        	// 多个线程同时进入 if 判断中，会产生多个实例
            instance = new Singleton();
        }
        
        return instance;
    }
}

虽然起到了懒加载的效果，但是只能在单线程下使用。如果在多线程下，一个线程进入了 if 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在实际开发中，不要使用这种方式。

1.2.4 懒汉式（同步方法）

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2020/12/23
 */
public class Singleton {

    /**
     * 私有构造方法
     */
    private Singleton() {};

    /**
     * 创建内部对象
     */
    private static Singleton instance;

    /**
     * 获取实例
     * 使用 synchronized 关键字修饰方法，将其声明为同步方法
     * @return Singleton
     */
    public static synchronized Singleton getInstance() {
        if (null == instance) {
            instance = new Singleton();
        }

        return instance;
    }
}

虽然解决了线程安全问题，但是效率太低了，每个线程在想获得类的实例时候，执行 getlnstance 方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低，在实际开发中，不推荐使用这种方式

1.2.5 懒汉式（同步代码块）

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2020/12/23
 */
public class Singleton {

    /**
     * 私有构造方法
     */
    private Singleton() {};

    /**
     * 创建内部对象
     */
    private static Singleton instance;

    /**
     * 获取实例
     * @return Singleton
     */
    public static Singleton getInstance() {
        if (null == instance) {
            // 多个线程进入 if 中依然会出现问题，该种方式只是在前进道路的探索，无法使用
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }

        return instance;
    }
}

1.2.6 懒汉式（双重检查）

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2020/12/23
 */
public class Singleton {

    /**
     * 私有构造方法
     */
    private Singleton() {};

    /**
     * 创建内部对象
     */
    private static Singleton instance;

    /**
     * 获取实例
     * @return Singleton
     */
    public static Singleton getInstance() {
        if (null == instance) {
            // 多个线程进入 if 中依然会出现问题
            synchronized (Singleton.class) {
                if (null == instance) {
                    instance = new Singleton();
                }
            }
        }

        return instance;
    }
}

双重检查是同步代码块的升级版，在多线程开发中常使用到的，如代码中所示，我们进行了两次 if 检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断 if ，直接 return 实例化对象，也避免的反复进行方法同步。线程安全；延迟加载；效率较高。在实际开发中，推荐使用。

1.2.7 懒汉式（静态内部类）

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2020/12/23
 */
public class Singleton {

    /**
     * 私有构造方法
     */
    private Singleton() {};

    /**
     * 创建静态内部类
     */
    private static class SingletonInstance {
        public static final Singleton INSTSNCE = new Singleton();
    }

    /**
     * 获取实例
     * @return Singleton
     */
    public static synchronized Singleton getInstance() {
        return SingletonInstance.INSTSNCE;
    }
}

这种方式采用了类装载的机制来保证初始化实例时只有一个线程。静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getlnstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。类的静态属性只会在第一次加载类的时候初始化，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。避免了线程不安全，利用静态内部类特点实现延迟加载，效率高，推荐使用。

1.2.8 懒汉式（枚举）

/**
 * @author Demo_Null
 * @version 1.0
 * @date 2020/12/23
 */
public enum Singleton {
    /**
     * 枚举项，是本类的实例
     */
    INSTSNCE;

    /**
     * 其他方法
     */
    public void show() {
        System.out.println("Hello World!");
    }
}