Java并发编程深入探讨：对象组合与线程安全

对象组合与线程安全：

在构建复杂的并发应用时，有效地组合现有的线程安全组件是关键。这不仅能够简化开发过程，还能提高系统的稳定性和性能。

设计线程安全的类：

设计线程安全的类主要涉及三个核心要素：

识别所有影响对象状态的变量；
确定这些变量之间的不变性条件；
制定有效的并发访问控制策略。

收集同步需求：

为了确保线程安全，必须理解对象的不变性条件和后验条件。这有助于在状态变量的有效值或状态转换上施加必要的约束，通常通过原子性和封装性来实现。

依赖状态的操作：

某些操作可能依赖于特定的状态条件，这类操作被称为依赖状态的操作。例如，在执行某项操作之前，需要检查当前状态是否允许执行该操作。

状态的所有权：

状态的所有权与封装性紧密相关。对象封装其状态，意味着它对其状态拥有所有权。这种所有权可以通过对象的传递变为共享所有权。

实例封闭：

通过将数据封装在对象内部，可以限制数据的访问范围，从而更容易确保线程在访问数据时持有正确的锁。

@ThreadSafe public class PersonSet { private final Set mySet = new HashSet<>(); public synchronized void addPerson(Person p) { mySet.add(p); } public synchronized boolean containsPerson(Person p) { return mySet.contains(p); } }

封闭机制使得构造线程安全的类更加容易，因为分析类的线程安全性时无需考虑整个程序的其他部分。

Java监视器模式：

Java监视器模式通过对象的内置锁保护所有可变状态，例如Vector和Hashtable等类。此外，也可以使用私有锁来替代内置锁。

public class PrivateLock { private final Object lock = new Object(); public void methodOne() { synchronized(lock) { // do something } } }

线程安全性的委托：

即使组合了多个线程安全的类，新组合的类也不一定是线程安全的。但是，通过将内部操作委托给线程安全的类，可以确保整体的安全性。

@ThreadSafe public class DelegatingPersonSet { private final Set mySet = Collections.synchronizedSet(new HashSet<>()); public void addPerson(Person p) { mySet.add(p); } public boolean containsPerson(Person p) { return mySet.contains(p); } }

独立的状态变量：

如果多个状态变量彼此独立（不相关），则可以将线程安全性委托给这些状态变量。

public class VisualComponent { private final List keyListeners = new CopyOnWriteArrayList<>(); private final List mouseListeners = new CopyOnWriteArrayList<>(); public void addKeyListener(KeyListener keyListener) { keyListeners.add(keyListener); } public void removeKeyListener(KeyListener keyListener) { keyListeners.remove(keyListener); } public void addMouseListener(MouseListener mouseListener) { mouseListeners.add(mouseListener); } public void removeMouseListener(MouseListener mouseListener) { mouseListeners.remove(mouseListener); } }

当委托失效时：

如果类中的多个状态变量之间存在不变性条件，即使这些变量各自是线程安全的，整个类也可能不是线程安全的。

@NotThreadSafe public class NumberRange { private final AtomicInteger lower = new AtomicInteger(); private final AtomicInteger upper = new AtomicInteger(); public void setLower(int i) { if (i > upper.get()) { throw new IllegalArgumentException("lower can't > upper"); } lower.set(i); } public void setUpper(int i) { if (i  upper"); } upper.set(i); } }

发布底层的状态变量：

如果一个状态变量是线程安全的，并且没有不变性条件约束其值，也没有不允许的状态转换，那么可以安全地发布这个变量。

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

可以通过扩展类来添加新的功能，但需要注意保持线程安全性。

public class NoRepeatVector extends Vector { public synchronized boolean putIfAbsent(E e) { boolean exist = contains(e); if (!exist) add(e); return exist; } }

客户端加锁机制：

客户端加锁是指使用对象自身的锁来保护客户端代码，确保操作的原子性。

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

上述代码实际上并不安全，因为锁住的是ListHelper对象而非list对象。正确的做法是对list加锁：

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

组合：

组合是一种更好的方法，用于在现有类中添加原子操作。

@ThreadSafe public class ImprovedList implements List { private final List list; public ImprovedList(List list) { this.list = list; } public synchronized boolean putIfAbsent(T t) { boolean absent = !list.contains(t); if (absent) list.add(t); return absent; } @Override public synchronized int size() { return list.size(); } ... }