利用对象限制和委托构建线程安全的类--Java Concurrency In Practice C04读书笔记

[本文是我对Java Concurrency In Practice第三章的归纳和总结.  转载请注明作者和出处,  如有谬误, 欢迎在评论中指正. ] 

设计线程安全的类需要考虑:

1. 确定组成对象状态的变量.

2. 确定约束对象状态的不变式.

3. 建立并发访问对象状态的规则.

 

后置条件: 由于某些变量的取值是有限制范围的, 改变状态变量之后需要检查改变后的状态是否合法. 后置条件要求进行额外的同步. 比如一个计数器, 当前的值为17, 那么进行一次操作之后其取值只能是18, 其他值都是非法的.

前置条件: 需要满足一定的条件操作才能继续进行. 多线程环境下, 可以使用内置的wait和notify机制, 在条件满足时通知另一个线程继续往下执行. 也可以使用阻塞队列, 信号量等实现. 

 

对象限制

借助封装, 可以将对象限制在类范围内(作为类的私有成员), 方法内部(作为方法的局部变量), 或者线程范围内(只能在特定线程中访问该对象).

将对象限制在类范围内的例子:

public class PersonSet { 
    private final Set<Person> mySet = new HashSet<Person>(); 

    public synchronized void addPerson(Person p) { 
        mySet.add(p); 
    } 

    public synchronized boolean containsPerson(Person p) { 
        return mySet.contains(p); 
    } 
} 

mySet对象不是线程安全的, 但是将mySet对象限制在PersonSet类中, 并通过synchronized同步所有访问mySet对象的方法, 而且mySet对象没有逃逸出PersonSet类范围, PersonSet就是一个线程安全的类.

由上面的例子可知, 受限的对象不能逃逸出所在的范围是非常重要的.

另一个例子是java.util.Collections类提供的一些静态方法, 比如Collections.synchronizedList(List<T> list)方法:

class SynchronizedList<E> extends SynchronizedCollection<E> implements List<E> {
	static final long serialVersionUID = -7754090372962971524L;

	final List<E> list;

	SynchronizedList(List<E> list) {
		super(list);
		this.list = list;
	}

	SynchronizedList(List<E> list, Object mutex) {
		super(list, mutex);
		this.list = list;
	}

	public boolean equals(Object o) {
		synchronized (mutex) {
			return list.equals(o);
		}
	}

	public int hashCode() {
		synchronized (mutex) {
			return list.hashCode();
		}
	}

	public E get(int index) {
		synchronized (mutex) {
			return list.get(index);
		}
	}
	// ....
}

可以看出SynchronizedList是对List的包装. SynchronizedList所有的方法都使用同一把锁mutex进行同步. 所以SynchronizedList是一个线程安全的类. 但是前提是被包装的list对象不能再直接使用, 必须通过synchronizedList(List<T> list)返回的对象进行访问(开发者必须遵循这样的约定, 否则线程安全就被破坏了), 也就是防止list对象逃逸出SynchronizedList类的范围.

 

委托线程安全. 先看一个例子:

public class DelegatingVehicleTracker {
    private final ConcurrentMap<String, Point> locations; 

    public DelegatingVehicleTracker(Map<String, Point> points) { 
	// 构造map的concurrent视图
        locations = new ConcurrentHashMap<String, Point>(points); 
    } 

    public Map<String, Point> getLocations() { 
    	// 返回map的unmodifiable视图
        return Collections.unmodifiableMap(locations); 
    } 

    public Point getLocation(String id) { 
        return locations.get(id); 
    } 

    public void setLocation(String id, int x, int y) { 
        if (locations.replace(id, new Point(x, y)) == null) 
            throw new IllegalArgumentException( 
                "invalid vehicle name: " + id); 
    }

    /**
     * 这是一个不可变类
     */
    public class Point { 
        public final int x, y; 
        public Point(int x, int y) { 
            this.x = x; 
            this.y = y; 
        } 
    }
}

DelegatingVehicleTracker只有一个状态变量: locations. locations是一个ConcurrentMap对象, 也就是说locations是线程安全的. 而且locations对象被限制在DelegatingVehicleTracker类范围内. 因此可以说, DelegatingVehicleTracker是一个线程安全的类因为locations是线程安全的. 换一种说法, DelegatingVehicleTracker将线程安全的责任委托给了locations对象. 

在构造函数里, 利用points的concurrent视图初始化locations. concurrent视图不同于synchronized视图, synchronized视图只是包装了一层同步, 方法的调用还有由原有的Map对象负责的, 因此JDK文档特别要求不能在外部继续调用原有Map的方法, 所以线程安全来源于约定, 如果开发者没有遵循约定, 线程安全就被破坏了. 但是concurrent视图并非如此, concurrent视图是对原有Map的浅拷贝, 也就是会遍历原有Map, 取出其中的每一个键值对, 然后将取出的键值对存入concurrent视图中. 因此concurrent视图仅和原有的Map共享了键和值的引用, 而由于Map的value(Point对象)是不可变的, 在外部直接调用原有的Map的任何方法, 都不会对concurrent视图造成影响.

我们可以总结出这样的规则: 如果类只包含一个状态变量, 那么类是否是线程安全的, 取决于该状态变量是否是线程安全的.

如果类中存在多个状态变量时, 委托规则是否仍然成立呢? 如下:

public class VisualComponent { 
    private final List<KeyListener> keyListeners 
        = new CopyOnWriteArrayList<KeyListener>(); 
    private final List<MouseListener> mouseListeners 
        = new CopyOnWriteArrayList<MouseListener>(); 

    public void addKeyListener(KeyListener listener) { 
        keyListeners.add(listener); 
    } 

    public void addMouseListener(MouseListener listener) { 
        mouseListeners.add(listener); 
    } 

    public void removeKeyListener(KeyListener listener) { 
        keyListeners.remove(listener); 
    } 

    public void removeMouseListener(MouseListener listener) { 
        mouseListeners.remove(listener); 
    } 
}

CopyOnWriteArrayList是ArrayList的线程安全的变体, keyListeners和mouseListeners是线程安全的对象, 而且keyListeners和mouseListeners是相互独立的, 所以VisualComponent也是线程安全的. 当状态变量之间不是相互独立的时候情况又如何呢? 如:

public class NumberRange { 
    // INVARIANT: lower <= upper 
    private final AtomicInteger lower = new AtomicInteger(0); 
    private final AtomicInteger upper = new AtomicInteger(0); 

    public void setLower(int i) { 
        // Warning -- unsafe check-then-act 
        if (i > upper.get()) 
            throw new IllegalArgumentException( 
                    "can't set lower to " + i + " > upper"); 
        lower.set(i); 
    } 

    public void setUpper(int i) { 
        // Warning -- unsafe check-then-act 
        if (i < lower.get()) 
            throw new IllegalArgumentException( 
                    "can't set upper to " + i + " < lower"); 
        upper.set(i); 
    } 

    public boolean isInRange(int i) { 
        return (i >= lower.get() && i <= upper.get()); 
    } 
} 

NumberRange类的状态变量lower和upper都是线程安全的对象, 但是lower和upper不是相互独立的, 两者需要满足不变式约束: lower <= upper. 假设lower和upper分别是0和10, 此时2个不同的线程同时调用setLower(5)和setUpper(4), 在某些不幸的时间点这2个方法的前置条件检查都能通过, 这就造成不变式约束不再成立. 因此NumberRange类不是线程安全的.

总结: 如果类中的状态变量之间是相互独立的, 那么线程安全的责任就可以委托给状态变量: 类是否线程安全, 取决于所有状态变量是否线程安全.