《Java并发编程实战》笔记4：对象的组合

1 如何设计一个线程安全的类？

在设计线程安全类的过程中，需要包含以下三个基本要素：

1. 找出构成对象状态的所有变量
2. 找出约束状态变量的不变性条件，后验条件
3. 建立对象状态的并发访问管理策略

2 什么是实例封闭

实例封闭机制（Instance Confinement）将一个对象X（通常非线程安全）封装到另一个对象A内部，只能通过A的方法访问X,并通过A的内置锁对方法加锁，则可以实现访问对象X的线程安全，这种方法交实例封闭。

// 线程安全的set
public class PersonSet {
    // mySet被this保护
    private final Set<Person> mySet = new HashSet<>();
    public synchronized void addPerson(Person p){
        mySet.add(p);
    }
    public synchronized boolean containsPerson(Person p){
        return mySet.contains(p);
    }
}

上面代码中 mySet初始化了一个private final的实例，并且mySet只能通过PersonSet的加内置锁方法addPerson()和containsPerson()访问，所以实现了线程安全。
Collections.synchronizedList及其类似方法都是通过线程封闭实现线程安全的。

3 线程的安全性委托

1. 线程的安全性委托（个人理解，可能不准确）：通过多个线程安全的类组合成的类A的线程安全性取决于组A的各个类，如果他们构成的A是线程安全的，我们可以说A的安全性委托给了构成它的类。如果A不是线程安全的，即构成的类中存在耦合关系，导致各状态之间存在不变性条件，委托就会失效。
2. 什么情况下可以实现安全性委托。如果一个类由多个独立且线程安全的状态变量组成，并且所有的操作中都不包含无效状态转换，那么可以将线程安全性委托给底层的状态变量。
3. 什么情况下可以发布状态变量。如果一个状态变量是线程安全的，并且没有任何不变性条件来约束它的值，在变量的操作上也不存在任何不允许的状态转换，那么就可以安全的发布这个变量。

4 在现有的线程安全的类中添加功能

1. 直接修改原始的类。（通常无法做到，你不能修改别人的源码）
2. 继承自这个类，进行扩展。（通常不适用，因为该类状态必须对子类公开才能扩展）
3. 客户端加锁（必须注意加锁加的是那一把锁）
4. 组合方式（注意底层状态引用是private final确保只有该引用指向底层对象）

通过客户端加锁实现“若没有则添加”

public class ListHelper<E> {
    public List<E> list = Collections.synchronizedList(new ArrayList<>());

    public boolean putIfAbsent(E x){
        synchronized (list){ // 确保和底层list都是加的同一把锁
            boolean absent = !list.contains(x);
            if (absent)
                list.add(x);
            return absent;
        }
    }
    // 其他方法....
}

通过组合实现“若没有则添加”

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

    public ImprovedList(List<T> list){ this.list = list; }
public synchronized boolean putIfAbsent(T x){
        boolean contains = list.contains(x);
        if (contains)
            list.add(x);
        return !contains;
    }

    public synchronized void clear(){list.clear();}
    // ......其他方法略
}