对象发布

0.摘要

　　主要讨论了在多线程并发环境下，安全发布的几种方式（多种单例模式演示 ）。

1.基本概念

　　发布对象：使对象能够被当前范围之外的代码所看见。比如通过类的非私有方法返回对象的引用。

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

　　不正确的发布对象会导致两种错误：

　　　　1）发布线程以外的任何线程都可以看到被发布对象的过期的值 

　　　　2）线程看到的被发布线程的引用是最新的，然而被发布对象的状态却是过期的

　　如何安全发布对象？四种方法

　　　　1）在静态初始化函数中初始化一个对象引用

　　　　2）将对象的引用保存到volatile类型域或者AtomicReference对象中

　　　　3）将对象的引用保存到一个由锁保护的域中

　　　　4）将对象的引用保存到某个正确构造对象的final类型域中（本文目前没涉及到）

2.懒汉模式

　　（1）最简单的一段：在第一次使用的时候创建

public class SingletonExample1 {
    private SingletonExample1() {
    }
    private static SingletonExample1 instance = null;

    public static SingletonExample1 getInstance() {
        if (instance == null) {
            instance = new SingletonExample1();
        }
        return instance;
    }
}

 　　分析：单线程的情况下，线程是安全的。在多线程的情况下，第7-9行代码会出现线程不安全的问题。两个线程同时调用这段代码的时候会拿到两个不同的实例，尽管并不会产生什么不好的情况，但是如果这个私有构造方法在实现的时候要做很多操作，如资源的释放、运算等。那么这样产生的单例是线程不安全的。

---

　　（2）推荐和线程安全一段：上述可以单独使用synchronized修饰getInstance()来保证线程安全，但是有可能会造成性能损耗。更好的方法

/**
 * 懒汉模式-双重同步锁单例模式
 * 单例在使用时候创建
 */
public class SingletonExample1 {
    private SingletonExample1() {
    }

    //单例对象
    private static SingletonExample1 instance = null;

    //静态工厂方法
    public static SingletonExample1 getInstance() {
        if (instance == null) {//双重检测机制
            synchronized (SingletonExample1.class) {//同步锁
                if (instance == null) {
                    instance = new SingletonExample1();
                }
            }
        }
        return instance;
    }
}

　　分析：但上述的代码并不是线程安全的，插播一个小知识点。

这里有一个知识点：CPU指令相关 
在上述代码中，执行new操作的时候，CPU一共进行了三次指令 
（1）memory = allocate() 分配对象的内存空间 
（2）ctorInstance() 初始化对象 
（3）instance = memory 设置instance指向刚分配的内存

　　在程序运行过程中，CPU为提高运算速度和JVM优化会做出违背代码原有顺序的优化。我们称之为乱序执行优化或者说是指令重排。 
　　那么上面知识点中的三步指令极有可能被优化为（1）（3）（2）的顺序。当我们有两个线程A与B，A线程遵从132的顺序，经过了两此instance的空值判断后，执行了new操作，并且cpu在某一瞬间刚结束指令（3），并且还没有执行指令（2）。而在此时线程B恰巧在进行第一次的instance空值判断，由于线程A执行完（3）指令，为instance分配了内存，线程B判断instance不为空，直接执行return，返回了instance，这样调用这个实例的时候会出现错误。

　　如何解决指令重排？

在对象声明时使用volatile（双重检测）关键字修饰，阻止CPU的指令重排。
private volatile static SingletonExample instance = null;

3.饿汉模式

　　（1）最简单的一段：在类装载的时候创建，能保证线程安全

//饿汉模式，在类装载的时候创建
public class SingletonExample1 {
    private SingletonExample1() {
    }
    
    private static SingletonExample1 instance = new SingletonExample1();

    public static SingletonExample1 getInstance() {
        return instance;
    }
}

　　分析：第一如果其私有构造函数中存在大量处理，那么类装载的时间会很长，第二如果只进行了类的加载却没有调用，会造成性能的浪费。（下面的分析有点长）

---

　　（2）通过静态块来初始化，注意静态代码块一定要在静态工厂方法的上面

public class SingletonExample {
    // 私有构造函数
    private SingletonExample() {
    }
    // 单例对象
    private static SingletonExample instance = null;
    static {
        instance = new SingletonExample();
    }
    // 静态的工厂方法
    public static SingletonExample getInstance() {
        return instance;
    }
}

4.枚举模式

/**
 *枚举模式
 */
public class SingletonExample2 {
    private SingletonExample2() {
    }

    public static SingletonExample2 getInstance() {
        return Singleton.INSTANCE.getSingleton();
    }

    private enum Singleton {
        INSTANCE;
        private SingletonExample2 singleton;

        //JVM来保证这个方法只被调用一次
        Singleton() {
            singleton = new SingletonExample2();
        }

        public SingletonExample2 getSingleton() {
            return singleton;
        }
    }

}

　　分析：由于枚举类的特殊性，JVM可以保证枚举类的构造函数只被调用一次，相比饿汉模式，在实际调用的时候才做初始化。相比懒汉模式更加安全。推荐使用。

5.小结

　　本文章是作者学习并发编程中的笔记总结，方面我温故，希望能帮到大家。主要总结了几种创建单例的方法，推荐使用枚举模式。

2019-05-14 16:09:33