【JavaSE】【多线程】单例模式

目录

一、设计模式1.1 单例模式1.1.1 饿汉模式1.1.2 懒汉模式 1.2 线程安全问题1.3 懒汉模式线程安全问题的解决方法1.3.1 原子性问题解决1.3.2 解决效率问题1.3.3 解决内存可见性问题和指令重排序问题

一、设计模式

在讲解案例前，先介绍一个概念设计模式：就是大佬们把一些经典问题整理出来，针对这些场景，大佬们总结出固定的套路，来解决这些问题。就类似棋谱一样的概念。

1.1 单例模式

单例模式：就是强制要求，某个类在某个程序中，只能有一个实例，只能new一个对象。比如在开发中一个类存有很大的数据量，new两三次就把空间占满了，这时就可以使用单例模式了。

1.1.1 饿汉模式

饿：指尽早创建对象。
饿汉模式：类对象在类中使用static修饰为静态成员，并将构造方法使用private修饰私有化。

下面写一个简单饿汉模式代码：

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

1.1.2 懒汉模式

懒：指尽量晚创建对象，甚至不创建。
懒汉模式：类对象在类中使用static修饰为静态成员，并赋值为null，并将构造方法使用private修饰私有化，只不过是在get方法中去实例化。

下面写一个简单懒汉模式代码：

class SingletonLazy {    private static SingletonLazy instance = null;    public static SingletonLazy getInstance() {        if(instance == null) {            instance = new SingletonLazy();        }        return instance;    }    private SingletonLazy() {            }}

1.2 线程安全问题

在多线程代码中我们要考虑上诉两中模式是否存在线程安全问题。

我们看饿汉模式中在类创建的同时直接就将对象实例化好了，后续就一个return操作，相当于只是读取操作，而读取操作是不涉及线程安全问题的，所以饿汉模式不存在线程安全问题。我们看懒汉模式中，是先进行一次判断操作，在进行实例化，那这样就涉及到不是原子性的了，所以懒汉模式存在线程安全问题。

1.3 懒汉模式线程安全问题的解决方法

1.3.1 原子性问题解决

这样的问题我们使用synchronized加锁操作就行。

可以加在get方法上，以当前类对象作为锁对象；也可以将if包含起来。

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

1.3.2 解决效率问题

在我们上面加了锁之后，创建完对象之后每次在调用get方法的时候，还是会加锁，这就会导致产生锁竞争，线程阻塞问题影响效率。
这种解决方式就是在这之前在判断一次对象是否为空就行了。

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

这可能两个相同的判空语句放在一起，感觉会有点别扭，但是其实两者的作用是天差地别的：

第一个语句是防止加了锁之后，在竞争锁导致效率低；第二个语句是为了保证判断和实例是原子的。

1.3.3 解决内存可见性问题和指令重排序问题

编译器是否会进行优化导致内存可见性问题的出现，是不一定的，人为也不好预测。所以在对象前面加上volatile修饰就好。

指令重排序：是编译器对代码执行的指令的顺序进行调整，以达到优化的目的。
就像去买东西一样，先买什么后买什么的顺序也会影响买东西花费的时间。

而在上诉代码中instance = new SingletonLazy();这个语句就有可能触发指令重排序问题。
这条语句主要执行三条主要指令;

申请内存空间；在空间上构造对象，也就是实例化对象；将内存空间的"首地址"赋值给引用变量。

正常的执行顺序是1->2->3，但是由于指令重排序会出现1->3->2的情况，
这样先执行了3操作，该对象就不为null了，其它线程就可以对这个还没有实例化的对象进行操作了。这也引发了线程不安全问题。

这个问题的解决方法也是在对象前面加上volatile修饰就好。

volatile主要作用是：

确保从内存中读取数据，避免内存可见性问题；确保读取和修改操作不会触发指令重排序问题。

代码：

class SingletonLazy {    private volatile static SingletonLazy instance = null;    private static Object block = new Object();    public static SingletonLazy getInstance() {        if (instance == null) {            synchronized (block) {                if (instance == null) {                    instance = new SingletonLazy();                }            }        }        return instance;    }    private SingletonLazy() {    }}