Java并发编程实战：对象组合的艺术-CSDN博客

Java并发编程实战：对象组合的艺术

本文基于《Java并发编程实战》第四章内容，深入探讨如何通过对象组合技术构建线程安全的类。作为开发者，我们不仅需要理解基础并发机制，更要掌握如何将这些机制组合运用，构建出健壮的并发系统。

线程安全类设计三部曲

设计线程安全类需要遵循三个核心步骤：

识别对象状态：确定构成对象状态的所有变量
明确状态约束：找出约束这些状态变量的不变性条件
制定同步策略：选择适当的并发控制机制

以简单的计数器为例：

@ThreadSafe
public final class Counter {
    @GuardedBy("this") private long value = 0;
    
    public synchronized long getValue() {
        return value;
    }

    public synchronized long increment() {
        if (value == Long.MAX_VALUE)
            throw new IllegalStateException("counter overflow");
        return ++value;
    }
}

当对象包含其他对象时，其状态会扩展到被包含对象的状态。例如，链表的线程安全性需要考虑所有节点的状态。

实例封闭技术

实例封闭是一种强大的线程安全技术，它将非线程安全对象封装在另一个对象中，通过控制访问路径来保证线程安全。

Java监视器模式

这是最简单的同步模式，使用对象内置锁（this）保护所有状态：

@ThreadSafe
public class PersonSet {
    @GuardedBy("this")
    private final Set<Person> mySet = new HashSet<>();
    
    public synchronized void addPerson(Person p) {
        mySet.add(p);
    }
    // 其他同步方法...
}

对于复杂场景，可以使用多个显式锁来提升并发度：

public class ThreadSafeClass {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    public void methodA() {
        synchronized(lock1) { /* 临界区A */ }
    }
    // 其他方法使用不同锁...
}

车辆追踪案例

一个典型的监视器模式应用是车辆位置追踪系统：

@ThreadSafe
public class MonitorVehicleTracker {
    @GuardedBy("this")
    private final Map<String, MutablePoint> locations;
    
    public synchronized Map<String, MutablePoint> getLocations() {
        return deepCopy(locations); // 返回副本而非实时数据
    }
    // 其他同步方法...
}

关键点在于返回数据副本而非实时引用，避免外部修改影响内部状态。

委托线程安全

当类由线程安全组件构成时，可以将线程安全委托给这些组件：

@ThreadSafe
public class DelegatingVehicleTracker {
    private final ConcurrentMap<String, Point> locations;
    
    public Map<String, Point> getLocations() {
        return Collections.unmodifiableMap(locations); // 返回不可修改视图
    }
    // 其他委托方法...
}

注意这里使用的Point必须是不可变对象，否则无法保证线程安全。

委托失效场景

当多个状态变量参与不变性条件时，单纯委托将失效：

public class NumberRange {
    private final AtomicInteger lower = new AtomicInteger(0);
    private final AtomicInteger upper = new AtomicInteger(0);
    
    public void setLower(int i) {
        if (i > upper.get()) // 竞态条件风险
            throw new IllegalArgumentException();
        lower.set(i);
    }
    // 其他方法...
}

这种情况下需要额外的同步机制来保证复合操作的原子性。

扩展线程安全类

当需要为现有线程安全类添加新操作时，有几种策略：

客户端加锁

@ThreadSafe
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;
        }
    }
}

组合方式

更健壮的方式是通过组合：

@ThreadSafe
public class ImprovedList<T> implements List<T> {
    private final List<T> list;
    
    public synchronized boolean putIfAbsent(T x) {
        boolean contains = list.contains(x);
        if (contains) list.add(x);
        return !contains;
    }
    // 委托其他List方法...
}