设计模式（二）单例模式_单例设计模式多重检查-CSDN博客

本文链接：https://blog.csdn.net/weixin_41272626/article/details/107161322

单例模式

单例模式
概述
1、单线程下的单例模式实现
2、多线程下的单例模式实现
- 2.1 内部类-延迟加载
- 2.2 双重检查(Double-Check idiom)
单例模式的优点
单例模式的使用场景
- 饿汉式懒汉式的比较
总结：

单例模式

概述

定义：确保一个类只有一个实例，并为整个系统提供一个全局访问点。
类型： 创建模式
结构：

1、单线程下的单例模式实现

立即加载：** 在类加载初始化的时候就主动创建实例；

延迟加载： 等到真正使用的时候才去创建实例，不用时不去主动创建。

在单线程环境下的两种经典的实现： 饿汉式单例(立即加载)、懒汉式单例(延迟加载)

饿汉式单例

// 饿汉式单例
public class Singleton1 {
 
    // 指向自己实例的私有静态引用，主动创建
    private static Singleton1 singleton1 = new Singleton1();
 
    // 私有的构造方法
    private Singleton1(){}
 
    // 以自己实例为返回值的静态的公有方法，静态工厂方法
    public static Singleton1 getSingleton1(){
        return singleton1;
    }
}

类加载的方式是按需加载，且加载一次。。这个类在整个生命周期中只会被加载一次，因此只会创建一个实例，在JVM层面上执行一次，所以饿汉式在单/多线程环境下都是天生线程安全。

测试：开10个线程打印hashCode值, 结果都是一样的。

/**
 *
 *@author Saiuna
 *@date 2020/7/6 12:45
 */
public class test {
    public static void main(String[] args) {

        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] =new Thread(()->{
                System.out.println(Singleton1.getInstance().hashCode());
            });;
        }

        for (int i = 0; i <  threads.length; i++) {
            threads[i].start();
        }
    }
}

懒汉式单例

/**
 *传统的懒汉模式，线程不安全
 *@author Saiuna
 *@date 2020/7/6 12:54
 */
public class Singleton2 {

  private static Singleton2 singleton;
  private Singleton2() { }

  public static Singleton2 getInstance() {
    // 被动创建，在真正需要使用时才去创建
    if (singleton == null) {
      singleton = new Singleton2();
    }
    return singleton;
  }
}

实例被延迟加载，用到时才会实例化一个对象并交给自己的引用。

注：懒汉式单例本身非线程安全的，多个线程同时访问会产生多个实例 (用上述测试案例测试会得到不同的hashCode)。至于详细的为什么不安全，就涉及到多线程的问题了。

多个线程同时竞争下， singleton的值对于其他线程是不可见的，会发生多个线程同时判断singleton都为null值，从而产生了多个实例。

2、多线程下的单例模式实现

懒汉式单例本身是非线程安全的，在多线程环境中很可能会产生多个实例。那如何保证线程安全呢

2.1 内部类-延迟加载

/**
 *懒汉模式，使用内部类实现延迟加载
 *@author Saiuna
 *@date 2020/7/6 14:11
 */
public class Singleton5 {

    private static class Holder {
        private static Singleton5 singleton5 = new Singleton5();
    }

    private Singleton5() {
    }

    public static Singleton5 getInstance() {
        return Holder.singleton5;
    }

}

使用内部类实现线程安全的懒汉式单例，也是一种效率比较高的做法, 为什么安全呢~与饿汉单例同理。

2.2 双重检查(Double-Check idiom)

/**
 *线程安全的懒汉式单例---双重检查(Double-Check idiom)
 *@author Saiuna
 *@date 2020/7/6 14:21
 */
public class Singleton6 {

    /**
     * 使用volatile关键字防止重排序，因为 new Instance()是一个非原子操作，可能创建一个不完整的实例
     */
    private static volatile Singleton6 singleton6;

    private Singleton6() {
    }

    public static Singleton6 getInstance() {
        // Double-Check idiom 第一次非 null检查，避免频繁上锁
        if (singleton6 == null) {
            synchronized (Singleton6.class) {
                // 只需在第一次创建实例时才同步
                if (singleton6 == null) {
                    singleton6 = new Singleton6();
                }
            }
        }
        return singleton6;
    }
}