Java并发编程之对象的发布与逸出

概念

发布：使对象能够在当前作用域之外的代码中使用
对象逸出：一种错误的发布，当一个对象还没构建完成时，就被其他线程所见。

不安全发布对象

import com.gwf.concurrency.annoations.NotThreadSafe;
import lombok.extern.slf4j.Slf4j;
import java.util.Arrays;

public class UnsafePublish {
    private String[] states = {"a","b","c"};

    /**
     * 通过public发布级别发布了类的域，在类的外部，任何线程都可以访问这个域
     * 这样是不安全的，因为我们无法检查其他线程是否会修改这个域导致了错误
      * @return
     */
    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()));

    }
}

• 这个代码通过public访问级别发布了类的域，在类的任何外部的线程都可以访问这些域
• 我们无法保证其他线程会不会修改这个域，从而使私有域内的值错误（上述代码中就对私有域进行了修改）

对象溢出

public class Escape {

    private int thisCannBeEscape = 0;

    public Escape(){
        new InnerClass();
    }
    private class  InnerClass{
        public InnerClass(){
            log.info("{}",Escape.this.thisCannBeEscape);
        }
    }

    public static void main(String[] args) {
        new Escape();
    }
}

• 这个内部类的实例里面包含了对封装实例的私有域对象的引用，在对象没有被正确构造完成之前就会被发布，有可能有不安全的因素在里面，会导致this引用在构造期间溢出的错误。
• 上述代码在函数构造过程中启动了一个线程。无论是隐式的启动还是显式的启动，都会造成这个this引用的溢出。新线程总会在所属对象构造完毕之前就已经看到它了。
• 因此要在构造函数中创建线程，那么不要启动它，而是应该采用一个专有的start或者初始化的方法统一启动线程
• 这里其实我们可以采用工厂方法和私有构造函数来完成对象创建和监听器的注册等等，这样才可以避免错误

安全发布的方法

1.懒汉式

public class SingletonExample {
    //私有构造函数
    private SingletonExample(){
    }

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

    //静态工厂方法
    public static SingletonExample getInstance(){
        if(instance==null){
            return new SingletonExample();
        }
        return instance;
    }
}

在多线程环境下，当两个线程同时访问这个方法，当两个线程都执行到if(instance==null)时，都判断为null，接下来同时执行new操作。这样类的构造函数被执行了两次。一旦构造函数中涉及到某些资源的处理，那么就会发生错误，懒汉式是线程不安全的，所以一般不建议使用这种方式。

2.懒汉式（synchronized）

在类的静态方法上使用synchronized修饰

 public static synchronized SingletonExample getInstance()

使用synchronized修饰静态方法后，保证了方法的线程安全性，同一时间只有一个线程访问该方法 ，但是会有性能损耗。

3.懒汉式（双重同步锁单例模式 ）

public class SingletonExample {
    // 私有构造函数
    private SingletonExample() {
    }
    // 单例对象
    private static SingletonExample instance = null;
    // 静态的工厂方法
    public static SingletonExample getInstance() {
        if (instance == null) { // 双重检测机制
            synchronized (SingletonExample.class) { // 同步锁
                if (instance == null) {
                    instance = new SingletonExample();
                }
            }
        }
        return instance;
    }
}

• 我们将上面的第二个例子(懒汉式（synchronized))进行了改进，由synchronized修饰方法改为先判断后，再锁定整个类，再加上双重的检测机制，保证了最大程度上的避免耗损性能。
• 这个方法是线程不安全的，可能大家会想在多线程情况下，只要有一个线程对类进行了上锁，那么无论如何其他线程也不会执行到new的操作上。接下来我们分析一下线程不安全的原因：

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

在程序运行过程中，CPU为提高运算速度会做出违背代码原有顺序的优化。我们称之为乱序执行优化或者说是指令重排。
那么上面知识点中的三步指令极有可能被优化为（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; 

4.饿汉式

public class SingletonExample {
    // 私有构造函数
    private SingletonExample() {

    }
    // 单例对象
    private static SingletonExample instance = new SingletonExample();

    // 静态的工厂方法
    public static SingletonExample getInstance() {
        return instance;
    }
}

• 饿汉模式由于单例实例是在类装载的时候进行创建，因此只会被执行一次，所以它是线程安全的。
• 该方法存在缺陷：如果构造函数中有着大量的事情操作要做，那么类的装载时间会很长，影响性能。如果只是做的类的构造，却没有引用，那么会造成资源浪费
• 饿汉模式适用场景为：（1）私有构造函数在实现的时候没有太多的处理（2）这个类在实例化后肯定会被使用

5.饿汉式（静态块初始化）

public class SingletonExample {
    // 私有构造函数
    private SingletonExample() {
    }
    // 静态域
    private static SingletonExample instance = null;
    //静态块
    static {
        instance = new SingletonExample();
    }
    // 静态的工厂方法
    public static SingletonExample getInstance() {
        return instance;
    }
    public static void main(String[] args) {
        System.out.println(getInstance().hashCode());
        System.out.println(getInstance().hashCode());
    }
}

• 除了使用静态域直接初始化单例对象，还可以用静态块初始化单例对象。
• 值得注意的一点是，静态域与静态块的顺序一定不要反，在写静态域和静态方法的时候，一定要注意顺序，不同的静态代码块是按照顺序执行的，它跟我们正常定义的静态方法和普通方法是不一样的。

6.枚举式

public class SingletonExample {

    private SingletonExample() {
    }

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

    private enum Singleton {
        INSTANCE;
        private SingletonExample singleton;

        Singleton() {
            singleton = new SingletonExample();
        }

        public SingletonExample getInstance() {
            return singleton;
        }
    }
}

• 由于枚举类的特殊性，枚举类的构造函数Singleton方法只会被实例化一次，且是这个类被调用之前。这个是JVM保证的。
• 对比懒汉与饿汉模式，它的优势很明显。