手写单例模式：不会就尴尬了

手写单例模式

介绍：

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

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

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

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

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

• 优点：
  1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
  2、避免对资源的多重占用（比如写文件操作）。

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

• 使用场景：

  1、要求生产唯一序列号。
  2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
  3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

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

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

1、饿汉式（线程安全）

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

/**
 * @title: Hunger 饿汉式（线程安全）
 * @@Description:
 * @Author sujiaying
 * @Date: 2021/7/29 12:47
 */

public class Hunger {
    private static Hunger instance  = new Hunger();
    private Hunger(){}
    public static Hunger getInstance(){
        return instance;
    }
}

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

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

/**
 * @title: Lazy 懒汉（线程不安全）加锁后安全
 * @@Description:
 * @Author sujiaying
 * @Date: 2021/7/29 12:51
 */

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）线程安全，效率高

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

/**
 * @title: DCL双检锁/双重校验锁（DCL，即 double-checked locking）线程安全，效率高
 * 区别于懒汉的加锁
 * dcl只锁创建单例，不锁获取单例，如果已经创建好了则不会加锁
 * @@Description:
 * @Author sujiaying
 * @Date: 2021/7/29 12:53
 */

public class DCL {
    private volatile static DCL instance;
    private DCL(){}
    public static DCL getInstance(){
        if(instance==null){
            synchronized (DCL.class){
                if(instance==null){
                    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保证了多线程并发访问的正确性。（一个类只会被初始化一次，虚拟机会保证一个类的构造器方法在多线程环境中被正确地加载，同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的构造方法）

public class Singleton {  
    private static class SingletonHolder {  
    	private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    	return SingletonHolder.INSTANCE;  
    }  
}

参考资料

设计模式解释大全：
菜鸟教程|设计模式
参考文章：
创建单例模式
更多创建方式：
六种单例模式实现