懒汉模式:
/**
* @author baikunlong
* @date 2020/9/12 9:20
* 单例模式1 懒汉模式
*/
public class Single1 {
//加上volatile关键字,解决双重检测的超小几率翻车,达到百分百单例
private static volatile Single1 single1;
//构造器改成私有,防止外部调用
private Single1() {
}
public static Single1 getSingle1() {
if (single1 == null) {
synchronized (Single1.class) {
//使用双重检查,解决了在方法体加同步锁带来的效率低下问题,这样只有当single1为空时那几个线程会进来
if (single1 == null) {
System.out.println("实例对象");
// single1 = new Single1();这一句是非原子操作,JVM会执行三个步骤
//1 给single1分配内存
//2 调用构造器初始化成员变量,形成实例
//3 将single1对象指向分配的内存(这步执行完就是非null)
//这三个步骤顺序是不能保证的,所以可能执行了3,2还没执行,其他线程就会直接拿到single1了(但是还没初始化),就会报错了
//解决办法就是实例对象加上volatile关键字,volatile关键字的⼀个作⽤是禁⽌指令重排,把single1声明为volatile之后,对它的写操作就会有⼀个内存屏障(什么是内 存屏障?),这样,在它的赋值完成之前,就不⽤会调⽤读操作。
//注意:volatile阻⽌的不是singleton = new Singleton() 这句话内部[1-2-3]的指令重排,⽽是保证了在⼀个写操作([1-2-3])完成之前,不会调⽤读操作(if (single1 == null))。
single1 = new Single1();
System.out.println(single1);
}
}
}
return single1;
}
public static void main(String[] args) {
for (int i = 0; i < 10000; i++) {
new Thread(() -> {
getSingle1();
}).start();
}
}
}
普通版饿汉模式:
/**
* @author baikunlong
* @date 2020/9/12 10:14
* 饿汉式的实现一
*/
public class Single2 {
private static final Single2 single=new Single2();
private Single2(){}
public static Single2 getSingle2(){
return single;
}
}
加强版饿汉模式:
/**
* @author baikunlong
* @date 2020/9/12 10:14
* 饿汉式的实现二
*/
public class Single3 {
//对于内部类来说,它是饿汉式模式,在SingletonHolder初始化的时候会由ClassLoader来保证同步,使single3是⼀个真单例。
//由于是内部类,只有当外部调用getSingle3时,才会初始化实例,则对外部来说这是一个懒汉式
private static class SingletonHolder{
private static final Single3 single3=new Single3();
}
private Single3(){}
public static Single3 getSingle3(){
return SingletonHolder.single3;
}
}