【设计模式】多线程场景下，对单例模式的理解

单例模式下线程不安全是什么？

package com.example.single;

public class SingleObject {

    //创建 SingleObject 的一个对象
    private static SingleObject instance = null;

    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}

    public static SingleObject getInstance() {
        if (instance == null) {
            instance = new SingleObject();
        }
        return instance;
    }
}

单例模式简单实现，不难看出此单例无法保证线程安全，因为没有加锁，在判空的时候，可能存在同时并发的线程同样判断到为空的情况，由此重复创建出一样的实例，这显然和单例模式的设计思想是违背的。
单从字面意思有点难理解。
在java类中，有一个方法，getHashCode()，哈希表，即一个类加载的时候，就会在哈希表上创建记录，并有对应的hashCode值。
由此，我们模拟一次并发线程的场景，看看多线程条件下，每次创建出来的实例，对应其哈希表的值是多少

引入JDK-JUC并发编程包

package com.example.thread;

import java.util.concurrent.CountDownLatch;

public class ThreadStart {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        //10次并发线程
        for(int i=0;i<10;i++){
            new Thread(new ThreadTest(countDownLatch,i+1)).start();
        }
        countDownLatch.countDown();
    }
}
package com.example.thread;

import com.example.single.SingleObject;

import java.util.concurrent.CountDownLatch;

public class ThreadTest implements Runnable{

    private CountDownLatch countDownLatch;

    private int threadNum;

    ThreadTest(CountDownLatch countDownLatch,int threadNum){
        this.countDownLatch = countDownLatch;
        this.threadNum = threadNum;
    }

    @Override
    public void run() {
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程："+this.threadNum+"创建出的实例:"+SingleObject.getInstance().hashCode());
    }
}

这里解释一下

• countDownLatch.await();
  这个方法调用后，线程就会卡在那边，不允许执行下去。直到for循环把所有线程创建完成后调用countDown()方法
• countDownLatch.countDown();
  方法即释放掉所有等待状态的线程，以实现模拟并发的场景。
  
  可以看到，线程10在创建实例的时候就出现的线程不安全的情况，重复创建了单例，也就是线程不安全的情况发生了。（因为10次并发请求基数比较少，没有出现这种情况可以多运行几次）

对上述代码进行改造，加锁（volatile和synchronized）

public class SingleObject {

    //创建 SingleObject 的一个对象
    private volatile static SingleObject instance = null;

    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}

    public static synchronized SingleObject getInstance() {
        if (instance == null) {
            instance = new SingleObject();
        }
        return instance;
    }
}

再次运行
多试几次效果都是一样的，故可以达到线程安全的效果
但很明显，每次都得加锁，当实际场景中，并发请求量是数亿级别的，这种实现方式显然不合适。效率太低。

再次改造

public class SingleObject {

    //创建 SingleObject 的一个对象
    private static SingleObject instance = new SingleObject();

    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}

    public static SingleObject getInstance() {
        return instance;
    }
}

使用饥汉单例方法实现，这种可以保证高的效率，但这种在类加载的时候就会一直存在内存中，没有懒加载的效果，无疑是浪费JVM的内存。

继续改造

双重校验锁DCL

package com.example.single;

public class SingleObject {

    //创建 SingleObject 的一个对象
    private volatile static SingleObject singleObject;

    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}

    public static SingleObject getInstance() {
        if(singleObject == null){
            synchronized (SingleObject.class){
                if(singleObject == null){
                    singleObject =  new SingleObject();
                }
            }
        }
        return singleObject;
    }
}

这种实现方式即可以保证线程安全，也可以保证高的效率，但具体业务场景实现起来有较大的难度

降低实现难度，还可以改造成静态内部类的方式实现。

public class SingleObject {
    private static class SingleObjectHolder{
        private static final SingleObject INSTANCE = new SingleObject();
    }
    private SingleObject(){}

    public static final SingleObject getInstance(){
        return SingleObjectHolder.INSTANCE;
    }

}

这种实现方式和双重校验锁有一样的功效，但实现起来简单

还有一种比较少用到的枚举方式实现

public enum SingleObject {
    INSTACE;
    public void whateverMethod() {
    }
}