手写单例模式

介绍：

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

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

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。

2、避免对资源的多重占用（比如写文件操作）。

缺点：

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

1、要求生产唯一序列号。

2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

注意事项：getInstance() 方法中需要使用同步锁synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

单例模式的几种实现方式：

1、饿汉式（线程安全）

类加载时就初始化实例，避免了多线程同步问题，天然线程安全。

解释：类加载的方式是按需加载，且只加载一次。因此，在上述单例类被加载时，就会实例化一个对象并交给自己的引用，供系统使用，即在线程访问单例对象之前，其就已经创建好了。线程每次都只能拿到这个唯一的对象。因此，饿汉式单例天生就是线程安全的。

/**
 * @Author: Jim Zhao
 * @Date: 2022/10/9 9:17
 * @Title: hunger 饿汉式 （线程安全的）
 * @Description:
 * @Since: 1.0
 */
public class Hunger {
    private static Hunger instance = new Hunger();
    private Hunger () {}
    public static Hunger getInstance() {
        return instance;
    }
}

2 . 懒汉式（线程不安全）

实例对象在第一次被调用的时候才真正构建的，而不是程序一启动就会自动构建。所以这种滞后构建的方式就叫做懒加载。这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，多线程场景下不要使用，因为可能会产生多个对象，不再是单例。

/**
 * @Author: Jim Zhao
 * @Date: 2022/10/9 9:24
 * @Title: lazy 懒汉式（线程不安全） 枷锁后安全
 * @Description:
 * @Since: 1.0
 */
public class Lazy {
    private static Lazy instance;
    private Lazy() {}
//    public static synchronized Lazy getInstance() {
    public static Lazy getInstance() {
        if (instance == null) {
            instance = new Lazy();
        }
        return instance;
    }
}

如注释部分：

public static synchronized Lazy getInstance()

懒汉式（线程安全，方法上加同步锁）

和上面 懒汉式（线程不安全）实现上唯一不同是：获取实例的getInstance()方法上加了同步锁。保证了多线程场景下的单例。

3、双检锁/双重校验锁（DCL，即 double-checked locking）线程安全，效率高

此种实现中不用每次需要获得锁，减少了获取锁和等待的事件。

/**
 * @Author: Jim Zhao
 * @Date: 2022/10/9 9:28
 * @Title: DCL双检锁/双重校验锁（DCL，即 double-checked locking）线程安全，效率高
 * 区别于懒汉的加锁
 * dcl只锁创建单例，不锁获取单例，如果已经创建好了则不会加锁
 * @Description:
 * @Since: 1.0
 */
public class DCL {
    private volatile static DCL instance;
    private DCL(){}
    public static DCL getInstance() {
        if (instance == null) {
            synchronized (DCL.class) {
                if (instance == null){
                    /**
                     * 1.为 instance 分配内存空间
                     * 2.初始化 instance
                     * 3.将 instance指向分配的内存地址
                     */
                    instance = new DCL();
                }
            }
        }
        return instance;
    }
}

问：为什么要有第二个if？

因为如果没有第二个if的话，在当前A线程获得锁的线程后可能有其他如B线程也在等待进入这个Class锁，A线程获取锁后创建实例，然后释放锁，之后等待池中的B线程获得锁，然后就会产生创建两个对象的错误情况。

问：instance为什么需要采⽤ volatile 关键字修饰？

instance采⽤ volatile 关键字修饰也是很有必要的，在上述代码中有下面这一句代码

instance= new DCL();

其实是分为三步执⾏的：

1.为 instance 分配内存空间

2. 初始化 instance

3. 将 instance指向分配的内存地址

但是由于 JVM 具有指令重排的特性，执⾏顺序有可能变成 1->3->2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致⼀个线程获得还没有初始化的实例。

*（例如，线程A 执⾏了 1 和3，此时线程B调⽤ getInstance() 后发现 instance不为空，因此返回instance，但此时instance还未被初始化。）

使⽤ volatile 可以禁⽌ JVM 的指令重排 ，保证在多线程环境下也能正常运⾏。

4、静态内部类实现单例（线程安全、效率高）

这种方式下 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。注意内部类SingletonHolder要用static修饰且其中的静态变量INSTANCE必须是final的。

即：静态内部类不会随着外部类的加载而加载 ，只有静态内部类的静态成员被调用时才会进行加载 , 这样既保证了惰性初始化，又由JVM保证了多线程并发访问的正确性。（一个类只会被初始化一次，虚拟机会保证一个类的构造器方法在多线程环境中被正确地加载，同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的构造方法）

/**
 * @Author: Jim Zhao
 * @Date: 2022/10/9 9:42
 * @Title: 静态内部类实现单例
 * @Description: （线程安全、效率高）
 * @Since: 1.0
 */
public class Singlenton {
    private static class SingletonHolder {
        private static final Singlenton INSTANCE = new Singlenton();
    }
    private Singlenton() {}
    public static final Singlenton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}