写一个高并发下面的单例模式_高并发编程-04-线程安全-单例模式详解

单例模式详解

1，编写单例模式

饿汉式：不会存在线程安全的问题

public class Singleton1 {

private Singleton1(){}

private static Singleton1 singleton1 = new Singleton1();

public static Singleton1 getInstance(){

return singleton1;

}

}

懒汉式：会存在线程安全的问题，需要进行同步控制

以下的写法存在线程安全，经过之前的学习，应该很容易看出来吧

public class Singleton2 {

private Singleton2(){}

private static Singleton2 singleton2;

public static Singleton2 getInstance(){

if(singleton2 == null){

singleton2 = new Singleton2();

}

return singleton2;

}

}

验证方式:

可以采用线程池的方式，创建多个线程去获取实例对象，观察获取到的实例对象是否是同一个

2，解决懒汉式的线程安全问题

方法一：给方法加上synchronized即可

方法二：双重检测机制

public static Singleton2 getInstance(){

if(singleton2 == null){

synchronized (Singleton2.class) {

if(singleton2 == null){

singleton2 = new Singleton2();

}

}

}

return singleton2;

}

3.2 指令重拍的问题(要注意一个指令重拍的问题，但是无法演示，只能YY。。。。。。)

上述的双重检测机制看似解决了线程安全的问题，但是有一个重要的概念-指令重排，指令重排是指实际执行时，JVM编译器并非一定按照我们预想的顺序去执行，会对指令的执行顺序进行调整，这个时候就可能会出现线程不安全的情况

来，我们好好分析下：

singleton2 = new Singleton2();

会被编译器编译成如下JVM指令：

memory= allocate();//1.分配对象的内存空间

ctorinstance(memory);//2。初始化对象

singleton2 = memory;//3.设置singleton2指向刚分配的内存空间

如果这个时候，经过指令重排后，执行顺序为1,3,2 那么结果会如何？

假设，线程A执行了1,3后，线程B抢到了CPU资源，此时线程B对于if的判断结果会是false，

但是实际返回的是一个没有完成初始化的对象。

4，解决指令重排的问题-volatile

private volatile static Singleton2 singleton2;

使用volatile就可以解决这个问题，可以保证执行的指令顺序始终按照我们预想的1,2,3来走

我们一次性把单例说完吧，接下来的实现方式跟多线程是没有关系的

5，静态内部类实现单例模式

使用classLoader的加载机制来实现懒加载

public class Singleton3 {

private static class Lazy{

private static final Singleton3 SINGLETON3 = new Singleton3();

}

private Singleton3(){}

public static Singleton3 getInstance(){

return Lazy.SINGLETON3;

}

}

解释下，两个关键点：

1，外部无法直接访问静态内部类

2，SINGLETON3对象的初始化时机并不是在单例类加载的时候，而是外界调用getInstance方法的时候

所以综上所述，可以保证线程安全

6，终极大招---反射怎么破？

上述讲了这么多的方式，但是通过反射可以将私有的构造方法设置为可访问，然后就可以创建很多不同的对象了

那怎么办？

终极大招，通过枚举

public enum SingletonEnum {

INSTANCE;

}

有了枚举，JVM会阻止反射获取枚举的私有构造方法

唯一的缺点就是：枚举是立即加载的模式