什么是发布对象？

发布对象是指使一个对象可以被当前范围以外的代码所使用安全

什么是对象逸出？

对象逸出是一种错误的发布，指当一个对象尚未构造完成时，就使它被其余线程所见多线程

逸出-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,该类是线程不安全的，而且很是不推荐这么写。jvm

不安全的发布-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类型域中this

d、将对象的引用保存到一个由锁保护的域中spa

如何安全的发布一个对象呢？

咱们以对不一样单例的实现，来讲明一下安全发布对象的方法线程

单例-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时加锁，就能够变为线程安全的code

单例-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会执行三步操做：一、memory=allocate() 分配对象的内存空间二、ctorInstance()初始化对象三、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() { } //一、memory = allocate() 分配对象的内存空间 // 二、 ctorInstance() 初始化对象 // 三、 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是咱们最推荐的单例写法，而且是线程安全的，它相比于懒汉模式在安全性方面更容易保证，相比于饿汉模式是在实际调用的时候才作最开始的初始化

并发编程（七）：安全发布对象