Java高并发--安全发布对象

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();这句其实是分三步完成的。

1. 分配对象的内存空间

2. 初始化对象

3. 设置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才是线程安全的实现。