并发编程——创建线程安全的类，对象组合

1.1 实例封闭
我们时常需要创建一个线程安全的类，那么第一步，收集同步需求，并将同步策略写成正式文档。例如：1.状态变量的上届和下届值，范围；2.依赖状态的操作：比如某些方法中，包含一些先验条件，再删除某个元素前，队列必须处于非空状态。

如果某个对象不是线程安全的，那么可以通过多种技术在多线程程序中安全地使用。我们可以确保该对象智能由单个线程访问（线程封闭），或者通过一个锁来保护对该对象的所有访问。封装简化了线程安全类的实现过程，它提供了一种实例封闭机制，通常也简称为封闭：当一个对象被封装到另一个对象中，能够访问被封装对象所有代码路径都是已知的。 通过将数据封装在对象内部，可以将对数据的访问限制在对象的方法上，从而更容易确保线程在访问数据时总能持有正确的锁

2.1监视器模式
JAVA的监视器模式，是一种代码约定，遵循JAVA监视器模式的对象会把所有可变状态都封装起来，并由对象自己的内置锁来保护。比如这样：

public class PrivateLock{
    private final object myLock = new object();
    Widget widget;
void someMehtod() {
        synchronized(myLock){
            //修改或访问Widget的状态
        }
    }
}

2.2在类中添加安全的功能（委托，客户端加锁，组合）
我们构造一个类，大多是对象都是组合对象，当我们将多个非线程安全的类组合为一个类的时候，JAVA监视器模式是非常有用的。但是如果类中的各个组件都一斤是线程安全的，那我们是否需要再增加一个额外的线程安全层呢？答案是“视情况而定”。

我们举一个客户端加锁的例子：

public class ListHelper<E>{
    public List<E> list = 
        Collections.synchronizedList(new ArrayList<E>());
    ...
    public syncharonized boolean putIfAbsent(E x){
        boolean absent = !list.contains(x);
        if(absent)
            list.add(x);
        return absent;
    }
}

上面的程序貌似是线程安全地，因为他将内容委托到了线程安全的容器中，然后还在自己的类中设置了同步方法。但其实他并不是线程安全地，这是因为，这段代码使用了两个锁，这意味着putIfAbsent相对于List的其他操作来说并不是原子地，因此就无法确保当putIfAbsent执行时另一个线程不会改变链表。就是说这是两个锁，锁一个的时候，可能链表还没上锁，链表内容可能就会变。

要想是这个方法能够正确实行，必须对对象X的客户端代码上锁：

public boolean putIfAbsent(E x){
    synchrionized(list){
        boolean absent = !list.contains(x);
        ... 
    }
}

那我们还可以用一种方法，就是组合，我们将会implents List 接口，然后通过对象组合的方式，为List添加一个原子操作：

public class ImprovedList<T> implements List<T>{
    private final List<T> list;

    public ImprovedList(List<T> list) {this.list = list;}

    publicsynchronized boolean putIfAbsent(T x){
        boolean contains = list.contains(x);
        if(contains)
            list.add(x);
        return !contains;
    }
public synchronized void clear() {list.clear();}
...//其他的List方法
}