多线程案例-单例模式

分手后的思念是犯贱 2024-02-05 13:31 22阅读 0赞

## 单例模式 ##

### 设计模式的概念 ###

> 设计模式好比象棋中的"棋谱".红方当头炮,黑方马来跳.针对红方的一些走法,黑方应招的时候有一些固定的套路.按照套路来走局势就不会吃亏.
> 
> 软件开发中也有很多常见的"问题场景".针对这些问题的场景,大佬们总结出了一些固定的套路.按照这些套路来实现代码,也不会吃亏

### 单例模式概念 ###

**单例 = 单个实例(对象)**

> **具体来说,就是某个类,在一个进程中,只应该创建出一个实例.(也就是原则上不应该有多个)**
> 
> **使用单例模式,就可对代码进行更严格的校验与检查.**
> 
> 期望让机器(编译器)能够对代码中指定的类,创建的实例个数,进行校验.如果发现创建多个实例了,就直接让编译器报错这种~~

这一点在很多场景上都需要,一般就是一个对象持有(管理)大量数据时,比如JDBC中的DataSource实例只需要一个.

**单例模式具体的实现方式有很多.最常见的是"饿汉"和"懒汉"两种**.

### 饿汉模式 ###

**类加载的同时,创建实例**.

> 也就是说实例在类加载的时候就创建了,创建时机非常早,相当于程序一启动,实例就创建了.

class Singleton {
        private static Singleton instance = new Singleton();
        private Singleton(){}
        public static Singleton getInstance() {
            return instance;
        }
    }
    
    public class TestSingleton {
        public static void main(String[] args) {
            Singleton.getInstance();
    
            Singleton s = new Singleton();
        }
    }

> 1.instance是Singleton类对象里持有的属性.类对象是指Singleton.class(就是从.class加载至内存中,表示类的一个数据结构).
> 
> 2.private Singleton() \{\} 是在设置私有构造方法,保证其它代码不能创建出新的对象.
> 
> 比如:Singleton s = new Singleton();在这里就无法执行
> 
> 3.其它代码如果想要获得这个类的唯一实例,就可以通过getInstance()方法获取.
> 
> **对于饿汉来说,getInstance直接返回Instance实例,这个操作本质上是"读操作",多个线程读取同一个变量,是线程安全的**.

### 懒汉模式-单线程版 ###

类加载的时候不创建实例.第一次使用的时候才创建实例.

class Singleton {
        private static Singleton instance = null;
        //这个引用先初始化为null,而不是立即创建实例.
        private Singleton() {}
        public static Singleton getInstance() {
            if(instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }

> 在这个代码中,首次调用getInstance时,instance引用为null.进入里面的if条件,把实例创建出来.如果后续再次调用,if就不进入.而是直接返回之前创建的引用了.
> 
> 这样设定,仍可以保证该类的实例是唯一一个.**于此同时,创建实例的时机就不是程序驱动的了,而是第一次调用getInstance时**(**操作执行时机看程序具体需求.大概率要比饿汉这种方式要晚一些,甚至有可能整个程序压根用不到这个方法,也就把创建的操作给省下了**).

> 注意:懒汉模式是比饿汉模式更好一些的.
> 
> 在计算机中,懒的思想非常有意义:
> 
> 比如有一个非常大的文件(10GB).有一个编辑器,使用编辑器打开这个文件.
> 
> 如果是按照"饿汉模式",编辑器就会先把这10GB的数据加载到内存中,然后再进行统一的展示.(即使加载了这么多数据,用户还得一点一点看,没法一下子看完这么多..)
> 
> 如果是按照"懒汉模式",编辑器就会只读取一小部分数据(比如只读10KB),把这10KB先展示出来.随着用户进行翻页之类的操作,再继续读后续的数据.

### 懒汉模式-多线程版 ###

上面的懒汉模式是线程不安全的.

> 线程安全发生在首次创建实例时.如果在多个线程中同时调用getInstance方法,就可能导致创建出多个实例.
> 
> 一旦实例已经创建好了,后面再多线程环境调用getInstance就不再有线程安全问题了(不再修改Instance了).

举个例子:

![1d91db23d7c540ba8f00200b68420569.png][]

譬如这种情况,两次的if条件都符合,会创建两个实例,显然不符合规定.

而这时就很容易想到使用synchronized来解决这个问题.

class Singleton {
        private static Object locker = new Object();
        private static Singleton instance = null;
        private Singleton() {}
        public static Singleton getInstance() {
            synchronized(locker) {
    
                if(instance == null) {
                    instance = new Singleton();
                }
            }
            return instance;
        }
    }

> 这样写确实可以解决线程安全的问题.但还是有一个问题:
> 
> 比如Instance已经创建过了.此时后续再调用getInstance就都是返回Instance实例了吧(于是此处的操作就是纯粹的读操作了,也就不会有线程安全问题了).
> 
> 此时,针对这个已经没有线程安全问题的代码,仍然时每次调用都先加锁再解锁,此时效率就非常低了!!!(加锁意味着会产生阻塞,一旦线程阻塞,啥时候能解除,就不知道了.你可以认为:只要一个代码里加锁了,基本注定就要和"高性能"无缘).

因此我们说,在不该加锁的时候是不能乱加的.

**解决方案:可以在加锁外面再套一层if,以判断是否加锁.(如果instance为null,说明是首次调用,首次调用就需要考虑线程安全问题->要加锁 / 如果非null,说明是后续调用->不必加锁)**

**再来看一下修改的代码:**

class Singleton {
        private static Object locker = new Object();
        private static Singleton instance = null;
        private Singleton() {}
        public static Singleton getInstance() {
            if (instance == null) {//第一个if判定的是是否加锁(保证执行效率)
                synchronized(locker) {
                    if(instance == null) {//第二个if判定的是是否要创建对象(保障线程安全)
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

> **但是又双有一个问题,就是指令重排序引起的线程安全问题.**
> 
> **我们知道,指令重排序,也是编译器优化的一种方式.(调整原有代码的执行顺序,保证逻辑不变的前提下,提高程序的效率).**
> 
> 这里指的就是instance = new Singleton();
> 
> 这条语句可以拆分成多个指令:**(1)申请一段内存空间 (2)在内存上调用构造方法,创建出这个实例 (3)把这个内存地址赋给Instance引用变量**
> 
> 正常情况下:是按照(1)(2)(3)顺序执行的,但编译器也可优化成(1)(3)(2)执行,多线程指令重排序可能有问题.

原因如下:

![f9d3bae1407c4370b75f0bd8bf05f734.png][]

**解决方案:给instance加上volatile(volatile可以防止指令重排序).**

**加上之后,针对这个变量的读写操作,就不会出现指令重排序了.**

**最后代码如下:**

class Singleton {
        private static Object locker = new Object();
        private static volatile Singleton instance = null;
        private Singleton() {}
        public static Singleton getInstance() {
            if (instance == null) {//第一个if判定的是是否加锁(保证执行效率)
                synchronized(locker) {
                    if(instance == null) {//第二个if判定的是是否要创建对象(保障线程安全)
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

[1d91db23d7c540ba8f00200b68420569.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/1829e16acbe94eef94aba5b8b98e4cf8.png
[f9d3bae1407c4370b75f0bd8bf05f734.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/7998c18ee6bb46b68e1e4ff8aa824459.png