Java高并发--安全发布对象
主要是学习慕课网实战视频《Java并发编程入门与高并发面试》的笔记
发布对像：使一个对象能够被当前范围之外的对象使用。
对象逸出：一种错误的发布。当一个对象还没有构造完成时，就使他被其他线程所见。
如何安全的发布对象？
- 在静态初始化函数中初始化一个对象引用
- 将对象的引用保存到volatile类型域或者AtomicReference中
- 将对象的引用保存到某个正确构造对象的final类型域中
- 将对象的引用保存到一个由锁保护的域中
单例模式
拿单例模式来说
@ThreadSafe
public class SingletonImp {
// 饿汉模式
private static SingletonImp singletonImp = new SingletonImp();
// 私有化（private）该类的构造函数
private SingletonImp() {
}
public static SingletonImp getInstance() {
return singletonImp;
}
public static void main(String[] args) {
System.out.println(SingletonImp.getInstance());
}
}
上面是“饿汉模式”的实现。这个实现是线程安全的，但是不能延迟加载。也就是说这个单例在类加载时就已经初始化，而不是在需要用到他的地方再初始化的，这在一定程度上造成了资源的浪费。
单例还经常有一种叫“懒汉模式”，也就是在需要用到的时候才初始化。
@NotThreadSafe
public class SingletonImp2 {
private static SingletonImp2 singletonImp2;
private SingletonImp2() {}
// 懒汉模式
public static SingletonImp2 getInstance() {
if (singletonImp2 == null) {
singletonImp2 = new SingletonImp2();
}
return singletonImp2;
}
public static void main(String[] args) {
System.out.println(SingletonImp2.getInstance());
}
}
这个程序实现了延迟加载，但是在多线程下，可能多个线程同时执行到if (singletonImp2 == null) {}导致同时创建了多个实例对象，这是线程不安全的实现。所以就有了下面的实现
@ThreadSafe
public class SingletonImp3 {
private static SingletonImp3 singletonImp3;
private SingletonImp3() {}
// 懒汉模式
public static SingletonImp3 getInstance() {
// 同步锁的加入
synchronized (SingletonImp3.class) {
if (singletonImp3 == null) {
singletonImp3 = new SingletonImp3();
}
}
return singletonImp3;
}
}
这个实现加了同步锁，因此是线程安全的，但是在实例被创建出来后每次getInstance都会加上同步锁（这是完全没有必要的，因为if条件中的语句不会被执行到了 ），严重拖慢了程序的性能。
完全可以在第一次创建实例时才上锁，其余时候不需要，基于此思想的实现一般称为“双重检测”，如下
@NotThreadSafe
public class SingletonImp4 {
private static SingletonImp4 singletonImp4;
private SingletonImp4() {}
public static SingletonImp4 getInstance() {
// 第一次创建时才加锁
if (singletonImp4 == null) {
synchronized (SingletonImp4.class) {
if (singletonImp4 == null) {
singletonImp4 = new SingletonImp4();
}
}
}
return singletonImp4;
}
}
注意，这个实现是线程不安全的。究其原因，singletonImp4 = new SingletonImp4();这句其实是分三步完成的。
分配对象的内存空间
初始化对象
设置singleton变量指向刚刚分配的内存
但是由于指令重排原因，第2步和第3步可能会被交换（这个顺序在单线程下没有影响）。我们再看这个程序，注意注释部分。假设线程B执行到第一个if处，同时线程A执行到第二个if处，且由于指令重排的原因，只完成了上面三步的第1和第3步，也就是说此时singletonImp4已经被分配了内存，有值了在线程B判断时，就会跳过if直接返回singletonImp4。但是singletonImp4还没有初始化！线程B取得了还未初始化的对象，一旦使用就会出现问题。
@NotThreadSafe
public class SingletonImp4 {
private static SingletonImp4 singletonImp4;
private SingletonImp4() {}
public static SingletonImp4 getInstance() {
if (singletonImp4 == null) { // 线程B
synchronized (SingletonImp4.class) {
if (singletonImp4 == null) { // 线程A
singletonImp4 = new SingletonImp4(); // 线程A
}
}
}
return singletonImp4;
}
}
考虑到volatile关键字可以禁止指令重排，声明singletonImp4时，添加volatile就可以解决这个问题了。
private static volatile SingletonImp4 singletonImp4;
这样volatile + double check才是线程安全的实现。
