什么是发布对象?
发布对象是指使一个对象能够被当前范围之外的代码所使用
什么是对象逸出?
对象逸出是一种错误的发布,指当一个对象还没有构造完成时,就使它被其他线程所见
逸出-demo
@Slf4j public class Escape { private int thisCanBeEscape = 0; public Escape() { new InnerClass(); } private class InnerClass{ public InnerClass() { log.info("{}", Escape.this.thisCanBeEscape); } } public static void main(String[] args) { new Escape(); } }
在此实例中Escape对象还没有构造完成,就访问了该对象的成员变量thisCanBeEscape,该类是线程不安全的,并且非常不推荐这么写。
不安全的发布-demo
@Slf4j public class UnsafePublish { private String[] states = {"a", "b", "c"}; public String[] getStates() { return states; } public static void main(String[] args) { UnsafePublish unsafePublish = new UnsafePublish(); log.info("{}", Arrays.toString(unsafePublish.getStates())); unsafePublish.getStates()[0] = "d"; log.info("{}", Arrays.toString(unsafePublish.getStates())); } }
输出为:[a,b,c]和[d,b,c] 这样发布的对象为线程不安全的,因为无法保证其他线程是否会修改states域,从而造成状态错误
安全发布对象的四种方法:
a、在静态初始化函数中初始化一个对象引用
b、将对象的引用保存到volatile类型域或AtomicReference对象中
c、将对象的引用保存到某个正确构造对象的final类型域中
d、将对象的引用保存到一个由锁保护的域中
如何安全的发布一个对象呢?
我们以对不同单例的实现,来说明一下安全发布对象的方法
单例-demo1
public class SingletonExample1 { //私有构造函数 private SingletonExample1() { } //单例对象 private static SingletonExample1 instance = null; //静态的工厂方法 public static SingletonExample1 getInstance() { //单线程没有问题,多线程的时候会出现问题 if (instance == null) { instance = new SingletonExample1(); } return instance; } }
此实例在单线程模式下没有任何问题,但在多线程模式下,如两个线程都同时运行到判断instance==null时,就有可能new出两个实例来,所以说这是线程不安全的,这也就是懒汉模式,此实例满足了a条件,如果再加上d条件,在判断是否为null时加锁,就可以变为线程安全的
单例-demo2
public class SingletonExample2 { //饿汉模式不足,如果构造方法中有过多的处理,会导致类加载的时候特别慢 //私有构造函数 private SingletonExample2() { } //单例对象 private static SingletonExample2 instance = new SingletonExample2(); //静态的工厂方法 public static SingletonExample2 getInstance() { return instance; } }
此demo是线程安全的,使用饿汉模式时需要注意两点,一是此类肯定被使用(避免造成资源浪费),二是私有的构造方法中没有过多的处理4
单例-demo3
public class SingletonExample3 { //私有构造函数 private SingletonExample3() { } //单例对象 private static SingletonExample3 instance = null; //静态的工厂方法 public static synchronized SingletonExample3 getInstance() { //单线程没有问题,多线程的时候会出现问题 if (instance == null) { instance = new SingletonExample3(); } return instance; } }
此demo即为demo1加锁的情况,是线程安全的,但是并不推荐这么写,因为这样虽然保证了线程安全,但在性能上有一定的开销
单例-demo4
/** * 懒汉模式 双重同步锁单例模式 * 单例实例在第一次使用时进行创建 * 双重检测机制不一定线程安全,因为有指令重排的存在 */ public class SingletonExample4 { //私有构造函数 private SingletonExample4() { } //单例对象 private static SingletonExample4 instance = null; //静态的工厂方法 public static SingletonExample4 getInstance() { //单线程没有问题,多线程的时候会出现问题 if (instance == null) { //双重检测机制 //同步锁 synchronized (SingletonExample4.class) { if (instance == null) { instance = new SingletonExample4(); } } } return instance; } }
此demo是懒汉模式的优化版本,但注意此demo不是线程安全的,因为有指令重排的存在,当执行instance=new SingletonExample4()时,cpu会执行三步操作:1、memory=allocate() 分配对象的内存空间 2、ctorInstance()初始化对象 3、instance = memory 设置instance指向刚分配的内存, 但是由于jvm和cpu的优化,会发生指令重排,如重排的结果变为1,3,2,在单线程的情况下没有任何问题,但是在多线程的情况下就可能发生问题,如果此时A线程执行到instance=new SingletonExample4(),发生了指令重排,执行到了第二步的3,此时instance已经执行了该对象的内存,但是该对象还没有初始化,如果在此时B线程正好执行到if(instance==null),此时该条件已经不成立,直接return,因为这个对象还没有初始化,直接去使用这个对象就可能发生问题。
单例-demo5
/** * 懒汉模式 双重同步锁单例模式 * 单例实例在第一次使用时进行创建 * 双重检测机制不一定线程安全,因为有指令重排的存在 */ public class SingletonExample5 { //私有构造函数 private SingletonExample5() { } //1、memory = allocate() 分配对象的内存空间 // 2、 ctorInstance() 初始化对象 // 3、 instance = memeory 设置instance指向刚分配的内存 //通过volatile和双重检测机制限制指令重排,volatile限制了代码的写操作 //单例对象,通过volatile限制代码发生指令重排 private volatile static SingletonExample5 instance = null; //静态的工厂方法 public static SingletonExample5 getInstance() { //单线程没有问题,多线程的时候会出现问题 if (instance == null) { //双重检测机制 //同步锁 synchronized (SingletonExample5.class) { if (instance == null) { instance = new SingletonExample5(); } } } return instance; } }
此demo是demo4的升级版,只要解决了指令重排问题,在上篇博客“线程安全性中”我们已经介绍了volatile可以限制代码发生指令重排,此demo是线程安全的。
单例-demo6
/** * 饿汉模式 * 单例实例在类装载时进行创建 */ @ThreadSafe public class SingletonExample6 { //饿汉模式不足,如果构造方法中有过多的处理,会导致类加载的时候特别慢 //私有构造函数 private SingletonExample6() { } //单例对象 静态域的初始化 private static SingletonExample6 instance = null; //静态块方式 static { instance = new SingletonExample6(); } //静态的工厂方法 public static SingletonExample6 getInstance() { return instance; } public static void main(String[] args) { System.out.println(getInstance().hashCode()); System.out.println(getInstance().hashCode()); } }
demo2是饿汉模式的静态代码域方式,此demo是饿汉模式的静态代码块方式,此demo也是线程安全的
单例-demo7
/** * 枚举模式:最安全 * 相比于懒汉模式在安全性方面更容易保证 * 相比于饿汉模式是在实际调用的时候才做最开始的初始化 */ public class SingletonExample7 { private SingletonExample7() { } //静态的工厂方法 public static SingletonExample7 getInstance() { return Singleton.INSTANCE.getSingleton(); } private enum Singleton{ INSTANCE; private SingletonExample7 singleton; //JVM保证这个方法绝对只调用一次,且是在这个类调用之前初始化的 Singleton() { singleton = new SingletonExample7(); } public SingletonExample7 getSingleton() { return singleton; } } }
此demo是我们最推荐的单例写法,并且是线程安全的,它相比于懒汉模式在安全性方面更容易保证,相比于饿汉模式是在实际调用的时候才做最开始的初始化