同步工具类

同步工具类可以是任何一个对象，只要它根据其自身的状态来协调线程控制流。阻塞队列（BlockingQueue）可以作为同步工具类，其他类型的同步工具类还包括信号量（Semaphore），栅栏（Barrier）以及闭锁（Latch）。在平台类库中还包含其他一些同步工具类的类，如果这些类还无法满足需要，那么可以创建自己的同步工具类。

闭锁

闭锁可以延迟线程的进度直到其到达终止状态。闭锁的作用相当于一扇门：在闭锁到达结束状态之前，这扇门一直是关着的，并且没有任何线程能通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。当闭锁到达结束状态后，将不会再改变状态，因此这扇门将永远保持打开状态。闭锁可以用来确保某些活动直到其他活动都完成后才继续执行，例如：

• 确保某个计算在其需要的所有资源都被初始化之后才继续执行。二元闭锁（包括两个状态）可以用来表示“资源R已经被初始化”，而所有需要R的操作都必须在这个闭锁上等待。
• 确保某个服务在其依赖的所有其他服务都已经启动之后才启动。每个服务都有一个相关的二元闭锁。当启动服务S时，将首先在S以来的其他服务的闭锁上等待，在所有依赖的服务都启动后会释放闭锁S，这样其他依赖S的服务才能继续执行。
• 等待直到某个操作的所有参与者（例如：在多玩家游戏中的所有玩家）都就绪再继续执行。在这种情况中，当所有的玩家都准备就绪时，闭锁将到达结束状态。

CountDownLatch是一种灵活的闭锁实现，可以在上述各种情况下使用，它可以使一个或多个线程等待一组事件发生。闭锁状态包括一个计数器，该计数器被初始化为一个正数，表示需要等待的事件数量。countDown方法将递减计数器，表示有一个事件已经发生了，而await方法等待计数器到达零，这表示所有需要的事件都已经发生。如果计数器的值为非零，那么await会一直阻塞直到计数器为零，或者等待中的线程中断，或者等待超时。

在下面的TestHarness中给出了闭锁的两种常见用法。TestHarness创建一定数量的线程，利用它们并发的执行指定的任务。它使用两个闭锁，分别表示“起始门（Start Gate）”和“结束门（End Gate）”。起始门计数器的初始值为1，而结束们计数器的初始值为工作线程数量。每个工作线程首先要做的就是在启动门上等待，从而确保所有线程都就绪后才开始执行。而每个线程要做的最后一件事情是调用countDown方法使事件数量减1，这能使主线程高效的等待直到所有工作线程都执行完成，因此可以统计所消耗的时间：

public class TestHarness {
	public long timeTasks(int nThread, final Runnable task) throws InterruptedException {
		final CountDownLatch startGate = new CountDownLatch(1);
		final CountDownLatch endGate = new CountDownLatch(nThread);
		
		for (int i = 0; i < nThread; i++) {
			Thread t = new Thread() {
				public void run() {
					try {
						startGate.await();
						try {
							task.run();
						} finally {
							endGate.countDown();
						}
					} catch(InterruptedException ignored) {}
				}
			};
			t.start();
		}
		long start = System.nanoTime();
		startGate.countDown();
		long end = System.nanoTime();
		return end - start;
	}
}

为什么要在TestHarness中使用闭锁，而不是在线程创建后就立即启动？或许，我们希望测试n个线程并发执行某个任务时需要的时间。如果在创建线程之后立即启动它们，那么先启动的线程将“领先”后启动的线程，并且活跃线程数量会随着时间的推移而增加或减少，竞争程度也在不断发生变化。起始门将使得主线程能够同时释放所有的工作线程，而结束门则使主线程能够等待最后一个线程执行完成，而不是顺序的等待每个线程执行完成。

FutureTask

FutureTask也可以用作闭锁。（FutureTask实现了Future语义，表示一种抽象的可生成结果的计算）。FutureTask表示的计算是通过Callable来实现的，相当于一种可生成结果的Runnable，并且可以处于以下3中状态：等待运行（Waiting to run），正在运行（Running）和完成运行（Completed）。“执行完成”表示计算的所有可能结束方式，包括正常结束、由于取消而结束和由于异常而结束等。当FutureTask进入完成状态以后，它会永远停止在这个状态上。

Future.get的行为取决于任务的状态。如果任务已经执行完成，那么get会立即返回结果，否则get将阻塞知道任务进入完成状态，然后返回结果或者抛出异常。FutureTask将计算结果从执行计算的线程传递到获取这个结果的线程，而FutureTask的规范确保了这种传递过程能实现结果的安全发布。

FutureTask在Executor框架中表示异步任务，此外还可以用来表示一些时间较长的计算，这些计算可以在使用计算结果之前启动。下面的程序就使用了FutureTask来执行一个高开销的计算，并且计算结果将在稍后使用。通过提前启动计算，可以减少在等待结果时需要的时间：

public class Preloader{
	private final FutureTask<ProductInfo> future = 
		new FutureTask<ProductInfo>(new Callable<ProductInfo>(){
			public ProductInfo call() throws DataLoadException{
				return loadProductInfo();
			}
		});
	private final Thread thread = new Thread(future);
	
	public void start() {thread.start();}
	
	public ProductInfo get() throws DataLoadException, InterruptedException{
		try {
			return future.get();
		} catch(ExecutionException e) {
			Throwable cause = e.getCause();
			if (cause instance of DataLoadException) {
				throw (DataLoadException)cause;
			} else {
				throw launderThrowable(cause);
			}
		}
	}
}

Preloader创建了一个FutureTask，其中包含从数据库加载产品信息的任务，以及一个执行运算的线程。由于在构造函数或静态初始化方法中启动线程并不是一种好方法，因此提供了一个start方法来启动线程。当程序虽有需要ProductInfo时，可以调用get方法，如果数据已经加载，那么将返回这些数据，否则将等待加载完成后再返回。

Callable表示的任务可以抛出受检查的或未受检查的异常，并且任何代码都可能抛出一个Error。无论任务代码抛出什么异常，都会被封装到一个ExecutionException中，并在Future.get中被重新抛出。这将使调用get的代码变得复杂，因为它不仅需要处理可能出现的ExecutionException（以及未检查的CancellationException），而且还由于ExecutionException是作为一个Throwable类返回的，因此处理起来并不容易。

信号量

计数信号量（Counting Semaphore）用来控制同时访问某个特定资源的操作数量，或者同时执行某个指定操作的数量。计数信号量还可以用来实现某种资源池，或者对容器施加边界。

Semaphore中管理着一组虚拟的许可（permit），许可的初始数量可通过构造函数来指定。在执行操作时可以首先获得许可（只要还有剩余的许可），并在使用以后释放即可。如果没有许可，那么aquire将阻塞直到有许可（或者直到被中断或者操作超时）。release方法将返回一个许可给信号量。计算信号量的一种简化形式是二值信号量，即初始值为1的Semaphore。二值信号量可以用作互斥体（mutex），并具备不可重入的加锁语义：谁拥有这个唯一的许可，谁就拥有了互斥锁。

Semaphore可以用于实现资源池，例如数据库连接池。我们可以构造一个固定长度的资源池，当池为空时，请求资源将会失败，但你真正希望看到的行为是阻塞而不是失败，并且当池非空时解除阻塞。如果将Semaphore的计数值初始化为池的大小，并在从池中获取一个资源之前先调用aquire方法获得一个许可，在将资源返回给池之后调用release释放许可，这样就实现了固定长度了。

同样，你可以使用Semaphore将任何一种容器变成有界阻塞容器，如下代码所示。信号量的计数值会初始化为容器容量的最大值。add操作在向底层容器中添加一个元素之前，首先需要获得一个许可。如果add操作没有添加任何元素，那么会立刻释放许可。同样remove操作释放一个许可，使更多的元素能够添加到容器中。底层的Set实现并不知道关于边界的任何信息，这是由BoundedHashSet来处理的。

public class BoundedHashSet<T> {
	private final Set<T> set;
	private final Semaphore sem;
	
	public BoundedHashSet(int bound) {
		this.set = Collections.synchronizedSet(new HashSet<T>());
		sem = new Semaphore(bound);
	}
	
	public boolean add(T o) throws InterruptedException {
		sem.aquire();
		boolean wasAdded = false;
		try {
			wasAdded = set.add(o);
			return wasAdded;
		} finally {
			if (!wasAdded) {
				sem.release();
			}
		}
	}
	
	public boolean remove(Object o) {
		boolean wasRemoved = set.remove(o);
		if (wasRemoved) {
			sem.release();
		}
		return wasRemoved;
	}
}

栅栏

我们已经看到通过闭锁来启动一组相关的操作，或者等待也组相关的操作结束。闭锁是一次性对象，一旦进入终止状态，就不能被重置。

栅栏（Barrier）类似于闭锁，它能阻塞线程直到某个事件发生。栅栏与闭锁的关键区别在于：所有线程必须同时到达栅栏位置，才能继续执行。闭锁也用于等待事件，而栅栏也用于等待其他线程。栅栏用于实现一些协议，例如几个家庭决定在某个地方集合：“所有人6:00在麦当劳碰头，到了以后要等其他人，之后再讨论下一步要做的事情。”

CyclicBarrier可以使一定数量的参与方反复地在栅栏位置汇集，它在并行迭代算法中非常有用：这种算法通常将也一个问题拆分成一系列相互独立的子问题。当线程到达栅栏位置时，将调用await方法，这个方法将阻塞直到所有线程都到达阻塞位置。如果所有线程都到达了栅栏的位置，那么栅栏将打开，此时所有线程都将被释放，而栅栏将被重置以便下次使用。如果对await的调用超时，或者await阻塞的线程被中断，那么栅栏就被认为是打破了，所有阻塞的await调用都将终止并抛出BrokenBarrierException。如果成功地通过栅栏，那么await将为每个线程返回一个唯一的到达索引号，我们可以利用这些索引来“选举”产生一个领导线程，并在下一次迭代中由该领导线程执行一些特殊的工作。CyclicBarrier还可以使你将一个栅栏参数传递给构造函数，这是一个Runnable，当成功通过栅栏时会（在下一个子任务线程中）执行它，但在阻塞线程被释放之前是不能执行的。

下面的例子中给出了如何通过栅栏来计算细胞的自动化模拟。在把模拟过程并行化时，为每个元素（这里为每个细胞）分配一个独立的线程是不现实的，也因为这将产生过多的线程，而在协调这些线程上导致的开销将降低计算性能。合理的做法是，将问题分解成一定数量的子问题，为每个子问题分配一个线程来进行求解，之后再将所有的结果合并起来。CellularAutomata将问题分解为Ncpu（可用的CPU数量）个子问题，并将每个子问题分配给一个线程。在每个步骤中，工作线程都为各自子问题中的所有细胞计算新值。当所有工作线程都到达栅栏时，栅栏会吧这些新值交给数据模型。在栅栏的操作执行完成以后，工作线程将开始下一步的计算，包括调用isDone方法来判断是否需要进行下一次迭代。

public class CellularAutomata {
	private final Board mainBoard;
	private final CyclicBarrier barrier;
	private final Worker[] workers;
	
	public CellularAutomata (Board board) {
		this.mainBoard = board;
		int count = Runtime.getRuntime().availableProcessors();
		this.barrier = new CyclicBarrier(count, new Runnable(){
			public void run() {
				mainBoard.commitNewValues();
			}
		});
		this.workers = new Worker[count];
		for (int i = 0; i < count; i++) {
			workers[i] = new Worker(mainBoard.getSubBoard(count, i));
		}
	}
	
	private class Worker implements Runnable {
		private final Board board;
		public Worker(Board board) {
			this.board = board;
		}
		public void run() {
			while(!board.hasConverged()) {
				for (int x = 0; x < board.getMaxX(); x++) {
					for (int y = 0; y < board.getMaxY(); y++) {
						board.setNewValue(x, y, computeValue(x, y));
					}
				}
				try {
					barrier.await();
				} catch(InterruptedException ex) {
					return;
				} catch(BrokenBarrierException ex) {
					return;
				}
			}
		}
	}
	
	public void start() {
		for (int i = 0; i < workers.length; i++) {
			new Thread(workers[i]).start();
		}
		mainBoard.waitForConvergence();
	}
}

另一种形式的栅栏就是Exchanger，它是一种两方（Two-Party）栅栏，各方在栅栏位置上交换数据。当两方执行不对称的操作时，Exchanger会非常有用，例如当也一个线程向缓冲区写入数据，而另一个线程从缓冲区中读取数据。这些线程可以使用Exchanger来汇合，并将满的缓冲区与空的缓冲区交换。当两个线程通过Exchanger交换对象时，这种交换就把这两个对象安全地发布给另一方。

数据交换的时机取决于应用程序的响应需求。最简单的方案是，当缓冲区被填满时，由填充任务进行交换，当缓冲区为空时，由清空任务进行交换。这样会把需要交换的次数降至最低，但如果新数据的到达率不可预测，那么一些数据的处理过程就将也延迟。另一个方法是，不仅当缓冲被填满时进行交换，并且当缓冲被填充到一定程度并保持也一定时间也以后，也进行交换。