Java 并发系列之十三：安全发布

Posted 2020-11-16 一只猫的旅行

1. 定义

• 发布对象（Publish）: 使一个对象能够被当前范围之外的代码所使用
• 对象逸出(Escape): 一种错误的发布。当一个对象还没有构造完成时，就使它被其他线程所见

2. 问题

正确发布一个对象遇到的两个问题：

　　(1)引用本身要被其他线程看到；

　　(2)对象的状态要被其他线程看到。

　　ps: 在多线程编程中，首要的原则，就是要避免对象的共享，因为如果没有对象的共享，那么多线程编写要轻松得多，但是，如果要共享对象，那么除了能够正确的将构造函数书写正确外，如何正确的发布也是一个很重要的问题。

　　

public class Client {
    public Holder holder;
    
    public void initialize(){
        holder = new Holder(42);//这个代码不是原子的
    }
}

public class Holder {
    int n;
    public Holder(int n) {
        this.n = n;
    }
    public void assertSanity() {
        if(n != n)
             throw new AssertionError("This statement is false.");
    }
}

/**
    在Client类中，Holder对象被发布了，但是这是一个不正确的发布。由于可见性问题，其他线程看到的Holder对象将处于不一致的状态，即使在该对象的构成构函数中已经正确的该构建了不变性条件，这种不正确的发布导致其他线程看到尚未创建完成的对象。主要是Holder对象的创建不是原子性的，可能还未构造完成，其他线程就开始调用Holder对象。

    由于没有使用同步的方法来却确保Holder对象（包含引用和对象状态都没有）对其他线程可见，因此将Holder成为未正确发布。问题不在于Holder本身，而是其没有正确的发布。上面没有正确发布的可能导致的问题：

    别的线程对于holder字段，可能会看到过时的值，这样就会    导致空引用，或者是过时的值（即使holder已经被设置了）（引用本身没有被别的线程看到）

    更可怕的是，对于已经更新holder，及时能够看到引用的更新，但是对于对象的状态，看到的却可能是旧值，对于上面的代码，可能会抛出AssertionError异常

    主要是holder = new Holder(42);这个代码不是原子性的，可能在构造未完成时，其他线程就会调用holder对象引用，从而导致不可预测的结果。
*/

 

3. 安全对象的构造过程

（1）在对象构造期间，不要公布this引用

public class EventListener { 
    public EventListener(EventSource eventSource) { 
        // do our initialization ... 
        // register ourselves with the event source 
        eventSource.registerListener(this); 
    } 
    public onEvent(Event e) { // handle the event } 
} 
public class RecordingEventListener extends EventListener { 
    private final ArrayList list; 
    public RecordingEventListener(EventSource eventSource) { 
        super(eventSource); 
        list = Collections.synchronizedList(new ArrayList()); 
    } 
    public onEvent(Event e) { 
        list.add(e); 
        super.onEvent(e); 
    } 
    public Event[] getEvents() { 
        return (Event[]) list.toArray(new Event[0]); 
    }  
} 

　　如果要在构造函数中创建内部类，那么就不能在构造函数中把他发布了，应该在构造函数外发布，即等构造函数执行完毕，初始化工作已全部完成，再发布内部类。

（2）不要隐式地暴露“this”引用

public class EventListener2 { 
    public EventListener2(EventSource eventSource) { eventSource.registerListener( 
            new EventListener() { 
                public onEvent(Event e) { 
                    eventReceived(e); 
                } 
     }); 
    } 
    public eventReceived(Event e) { } 
} 
同样也是子类化问题

（3）不要从构造函数内启动线程
   　　a）在构造函数中启动线程时，构造函数还未执行完毕，不能保证此对象已经完全构造
   　　b）如果在启动的线程中访问此对象，不能保证访问到的是完全构造好的对象

 

3. 安全发布常用模式

要安全的发布一个对象，对象的引用和对象的状态必须同时对其他线程可见。一般一个正确构造的对象（构造函数不发生this逃逸），可以通过如下方式来正确发布：

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

　　(2)将一个对象引用保存在volatile类型的域或者是AtomicReference对象中

　　(3)将对象的引用保存到某个正确构造对象的final类型的域中。

　　(4)将对象的引用保存到一个由锁保护的域

 

 

/**
（1）Java中存在三种对象
   a）不变对象：对象状态创建后不能再修改，对象的所有域为final，对象是正确构造的
   b）基本不变对象：不满足不变对象的约束，但是初始化后不再变化
   c）可变对象：不满足上述不变对象和基本不变对象的约束

（2）安全发布技术
   a）即确保对象引用和状态对其他线程正确可见
   b）方式
      静态初始化器初始化对象引用
      将引用存储到volatile域
      将引用存储到正确创建对象的final域
      将引用存储到由锁正确保护的域

（3）三种对象安全发布方式
   a）不变对象：任何形式机制发布
   b）基本不变对象：保证安全发布即可
   c）可变对象：不仅要保证安全发布，而且要确保对象状态的正确改变（即用锁或其他方式，保证对象状态的正确改变）
**/

 

 

 

4. 容器安全发布保证

　　在线程安全容器内部同步意味着，在将对象放到某个容器中，比如Vector中，将满足上面的最后一条需求。如果线程A将对象X放到一个线程安全的容器中，随后线程B读取这个对象，那么可以确保可以确保B看到A设置的X状态，即便是这段读/写X的应用程序代码没有包含显示的同步。下面容器内提供了安全发布的保证：

　　(1)通过将一个键或者值放入Hashtable、synchronizedMap或者ConcurrentMap中，可以安全将它发布给任何从这些容器中访问它的线程。

　　(2)通过将某个元素放到Vector、CopyOnWriteArrayList、CopyOnWriteArraySet、synchroizedList，可以将该元素安全的发布到任何从这些容器中访问该元素的线程。

　　(3)通过将元素放到BlockingQueue或者是ConcrrentLinkedQueue中，可以将该元素安全的发布到任何从这些访问队列中访问该元素的线程。

5. 补充

　　通常，要发布一个静态构造的对象，最简单和最安全的方式是使用静态初始化器： public static Holder = new Holder(42);

　　静态初始化器由JVM在类的初始化阶段执行，由于JVM内部存在同步机制，所以这种方式初始化对象都可以被安全的发布。

　　对于可变对象，安全的发布之时确保在发布当时状态的可见性，而在随后的每次对象的访问时，同样需要使用同步来确保修改操作的可见性。（状态可见性+同步）