《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;
	}
}

• 同步策略（Synchronization Policy）定义了如何在不违背对象不变条件或后验条件的情况下对其状态的访向操作进行协同。同步策略规定了如何将不可变性、线程封闭与加锁机制等结含起来以维护线程的安全性，并且还规定了那些变量由哪些锁来保护.要确保开发人员可以对这个类进行分析与维护，就必须将同步策略写为正式文档。

收集同步需求

• 如果不了解对象的不变性条件与后验条件，那么就不能确保线程安全性。要满足在状态变量的有效值或状态转换上的各种约束条件，就需要借助原子性与封装性。

依赖状态的操作

状态的所有权

• 在定义哪些变量将构成对象状态时，只考虑对象拥有的数据。

实例封闭

• 如果某对象不是线程安全的，那么可以通过多种技术使其在多线程程序中安全地使用。你可以确保该对象只能由单个线程访问（线程封闭），或者通过一个锁来保护对该对象的所有访问。
• 封装简化了线程安全类的实现过程，它提供了一种实例封闭机制（Instance Confinement），通常也简称为“封闭”。
• 将数据封装在对象内部，可以将数据的访问限制在对象的方法上，从而更容易确保线程在访问数据时总能持有正确的锁。

// 通过封闭机制来确保线程安全

@ThreadSafe
public class PersonSet {
	@GuardedBy("this")
	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);
	}
}

• 实例封闭式构建线程安全类的一个最简单方式，它还使得在锁策略的选择上拥有了更多的灵活性。
• 封闭机制更易于构造线程安全的类，因为当封闭类的状态时，在分析类的线程安全性时就无须检查整个程序。

Java监视器模式

• 从线程封闭原则及其逻辑推论可以得出Java监视器模式。遵循Java监视器模式的对象会把对象的所有可变状态都封装起来，并由对象自己的内置锁来保护。

// 通过一个私有锁来保护状态

public class PrivateLock {
	private final Object myLock = new Object();
	@GuardedBy("myLock") Widget widget;
	
	void someMethod () {
		synchronized (myLock) {
			// 访问或修改Widget的状态
		}
	}
}

• 使用私有的锁对象而不是对象的内置锁（或任何其他可通过公有方式访问的锁），有许多优点。私有的锁对象可以将锁封装起来，使客户代码无法得到锁，但客户代码可以通过公有方法来访问锁，以便（正确或者不正确地）參与到它的同步策略中，如果客户代码错误地获得了另一个对象的锁，那么可能会产生活跃性问题。此外，要想验证某个公有访问的锁在程序中是否被正确地使用，则需要检査整个程序，而不是单个的类。

示例：车辆追踪

// 基于监视器模式的车辆追踪

@ThreadSafe
public class MonitorVehicleTracker {
	@GuardedBy("this")
	private final Map<String, MutablePoint> locations;
	
	public MonitorVehicleTracker (Map<String, MutablePoint> locations) {
		this.locations = deepCopy(locations);
	}
	
	public synchronized Map<String, MutablePoint> getLocations () {
		return deepCopy(locations);
	}
	
	public synchronized MutablePoint getLocation (String id) {
		MutablePoint loc = locations.get(id);
		return loc == null ? null :  new MutablePoint(loc);
	}
	
	public synchronized void setLocation (String id, int x, int y) {
		MutablePoint loc = locations.get(id);
		if (loc == null) {
			throw new IllegalArgumentException("No such ID：" + id);
		}
		loc.x = x;
		loc.y = y;
	}
	
	private static Map<String, MutablePoint> deepCopy (Map<String, MutablePoint> m) {
		Map<String, MutablePoint> result = new HashMap<String, MutablePoint>();
		for (String id : m.ketSet()) {
			result.put(id, new MutablePoint(m.get(id)));
		}
		return Collections.unmodifiableMap(result);
	}
}

// 与Java.awt.Point类似的可变Point类

@NotThreadSafe
public class MutablePoint {
	public int x, y;
	
	public MutablePoint () {
		x = 0;
		y = 0;
	}
	public MutablePoint (MutablePoint p) {
		this.x = p.x;
		this.y = p.y;
	}
}

线程安全性委托

示例：基于委托的车辆追踪器

// 在 DelegatingVehicleTrcker 中使用的不可变Point类

@Immutable
public class Point {
	public final int x, y;
	public Point (int x, int y) {
		this.x = x;
		this.y = y;
	}
}

• 由于Point类是不可变的，因而它是线程安全的。不可变的值可以被自由地共享与发布，因此在返回location时不需要复制。

// 将线程安全委托给 ConcurrentHashMap

@ThreadSafe
public class DelegatingVehicleTracker {
	private final ConcurrentMap<String, Point> locations;
	private final Map<String, Point> unmodifiableMap;
	
	public DelegatingVehucleTracker (Map<String, Point> points) {
		locations = new ConcurrentHashMap<String, Point>(points);
		unmodifiableMap = Collections.unmodifiableMap(locations);	
	}
	
	public Map<String, Point> getLocations () {
		return unmodifiableMap;
	}
	
	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);
		}
	}
}

// 返回 locations 的静态拷贝而非实时拷贝

public Map<String, Point> getLocations () {
	return Collections.unmodifiableMap(new HashMap<String, Point>(locations));
}

独立的状态变量

// 将线程安全性委托给多个状态变量

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);
	}	
}

当委托失效时

// NumberRange 类并不足以保护它的不变性条件

public class NumberRange {
	// 不变性条件：lower <= upper
	
	private final AtomicInteger lower = new AtomicInteger(0);
	private final AtomicInteger upper = new AtomicInteger(0);
	
	public void setLower (int i) {
		// 注意 --- 不安全的“先检查后执行”
		if (i > upper.get()) {
			if (i > upper.get()) {
				throw new IllegalArgumentException("can't set lower to " + i + " > upper");
			}
			lower.set(i);
		}
	}
	
	public void setUpper (int i) {
		// 注意 --- 不安全的“先检查后执行”
		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());
	}
}

• 如果一个类是由多个独立且线程安全的状态变量组成，并且在所有的操作中都不包含无效状态转换，那么可以将线程安全性委托给底层的状态变量。

发布底层的状态变量

• 如果一个状态编程是线程安全的，并且没有任何不变性条件来约束它的值，在变量的操作上也不存在任何不允许的状态转换，那么就可以安全地发布这个变量。

示例：发布状态的车辆追踪器

// 线程安全且可变的Point类

@ThreadSafe
public class SafePoint {
	@GuardedBy("this") private int x, y;
	
	private SafePoint (int[] a) { this(a[0], a[1]); }
	
	public SafePoint (SafePoint p) { this(p.get()); }
	
	public synchronized int[] get () {
		return new int[] { x, y };
	}
	
	public synchronized void set (int x, int y) {
		this.x = x;
		this.y = y;
	}
}

// 安全发布底层状态的车辆追踪器

@ThreadSafe
public class PublishingVehicleTracker {
	private final Map<String, SafePoint> locations;
	private final Map<String, SafePoint> unmodifiableMap;
	
	public PublishingVehicleTracker (Map<String, SafePoint> locations) {
		this.locations 
			= new ConcurrentHashMap<String, SafePoint>(locations);
		this.unmodifiableMap
			= Collections.unmodifiableMap(this.locations);	
	}
	
	public Map<String, SafePoint> getLocations () {
		return unmodifiableMap;
	}
	
	public SafePoint getLocation (String id) {
		return locations.get(id);
	}
	
	public void setLocation (String id, int x, int y) {
		if (!locations.containsKey(id)) {
			throw new IllegalArgumentException("invalid vehicle name：" + id);
		}
		locations.get(id).set(x, y);
	}
}

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

// 扩展Vector并增加一个“若没有则添加”方法

@ThreadSafe
public class BetterVector<E> extends Vector<E> {
	public synchrnized boolean putIfAbsent (E x) {
		boolean absent = !contains(x);
		if (absent) {
			add(x)
		}
		return absent;
	}
}

• “扩展”方法比直接将代码添加到类中更加脆弱，因为現在的同步策略实现被分布到多个单独维护的源代码文件中。如果底层的类改变了同步策略并选择了不同的锁来保护它的状态变量，那么子类会被破坏，因为在同步策略改变后它无法再使用正确的锁来控制对基类状态的并发访问。（在Vector的规范中定义了它的同步策略，因此Bettervector不存在这个问题。）

客户端加锁机制

• 对于由Collections.synchronizedList封装的ArrayList，这两种方法在原始类中添加一个方法或者对类进行扩展都行不通，因为客户代码并不知道在同步封装器工厂方法中返回的List对象类型。第三种策略是扩展类的功能，但并不是扩展类本身，而是将扩展代码放入一个“辅助类”中。

// 非线程安全的“若没有则添加”

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

• 为什么这种方式不能实现线程安全性？毕竟，putlfAbsent 已经声明为 synchronized 类型的变量，对不对？问题在于在错误的锁上进行了同步。无论List使用哪一个锁来保护它的状态，可以确定的是，这个锁并不是 ListHelper 上的锁。ListHelper 是带来了同步的假象，尽管所有的链表操作都被声明为synchronized，但却使用了不同的锁，这意味着 putlfAbsent 相对于 List 的其他操作来说并不是原子的，因此就无法确保当putlfAbsent执行时另一个线程不会修改链表。

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

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

• 通过添加一个原子操作来扩展类是脆弱的，因为它将类的加锁代码分布到多个类中。然而，客户端加锁却更加脆弱。因为它将类C的加锁代码放到与C完全无关的其他类中。当在那些并不承诺遵循加锁策略的类上使用客户端加锁时，要特别小心。
• 客户端加锁机制与扩展类机制有许多共同点，二者都是将派生类的行为与基类的实现耦合在一起。正如扩展会破坏实现的封装性，客户端加锁同样会破坏同步策略的封装性。

组合

• 当为现有的类添加一个原子操作时，有一种更好的方法：组合。

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

@ThreadSafe
public class ImproveList<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();
	}
	// ...按照类似的方式委托List的其他方法
}

将同步策略文档化