什么是发布对象？

  发布对象是指使一个对象能够被当前范围之外的代码所使用

  什么是对象逸出？

  对象逸出是一种错误的发布，指当一个对象还没有构造完成时，就使它被其他线程所见

  逸出-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是我们最推荐的单例写法，并且是线程安全的，它相比于懒汉模式在安全性方面更容易保证，相比于饿汉模式是在实际调用的时候才做最开始的初始化