常见同步工具类
- 闭锁
- FutureTask
- 信号量
- 栅栏
- 阻塞队列
- 构建自己的同步工具类
介绍
- 同步工具类可以是任何一个对象，只要他根据自身的状态来协调线程的控制流程。
- 同步工具类都包含一些特定的结构化属性：他们封装了一些状态，这些状态将决定执行同步工具类的线程时继续执行还是等待。此外还提供操作状态的方法，以及另外一些方法用于高效地等待同步工具类进入到预期状态。（这段话通过使用一个同步工具类就可以理解了）
闭锁
介绍
- 闭锁相当于一扇门，在闭锁达到结束之前，门是关着的，任何线程不能通过，当到结束状态时，这扇门会打开，之后状态不会再改变，门打开后任何线程都允许通过。
- 闭锁是一次性对象，一旦进入终止状态就不能被重置，而栅栏可以重置。
作用
-
image.png
Java实现
- java实现类：CountDownLatch
- 闭锁状态包含一个计数器，标识需要等待的事件数量。
- 通过构造函数指定计数器值。
- 两个方法：countDown方法递减计数器值，表示一个事件已经发生。
await方法等待计数器值到达零，表示所有等待事件都已发生。 - await方法阻塞式，至到计数器为0，或等待中的线程中断或等待超时。
案例
- 演示闭锁的两种常见使用。主线程中等所有子线程都就绪和等所有子线程都执行完。
- TestHarness创建一定数量线程，利用它们并发的执行指定任务，只有所有线程都就绪后才可以执行。每个线程执行完后调用countDown方法减一，让主线程能高效的等所有线程都结束。
public class TestHarness {
public long timeTasks(int nThreads, final Runnable task)
throws InterruptedException {
final CountDownLatch startGate = new CountDownLatch(1);
final CountDownLatch endGate = new CountDownLatch(nThreads);
for (int i = 0; i < nThreads; 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();
endGate.await();
long end = System.nanoTime();
return end - start;
}
}
FutureTask
- 实现Runnable、Future接口，但run中的计算通过Callable来实现，Callable通过构造函数传入。
- 3种状态：等待运行、运行、完成。
- 完成状态表示计算的所有可能结束方式：正常结束、取消而结束、异常结束等。
- Future.get的行为取决于任务的状态，任务完成返回结果，否则阻塞知道任务进入完成状态，然后返回结果或抛出异常。
- Callable表示的任务可以抛出受检查或未受检查异常，并且可能抛出Error（如果任务代码中有严重错误），这些异常都会被封装到ExecutionException中，所以ExecutionException是Throwable类(Error和Exception的父类)，并在Future.get中重新被抛出。
- FutureTask将计算结果从执行计算的线程传递到获取结果的线程。
案例
package net.jcip.examples;
import java.util.concurrent.*;
/**
* Preloader
*
* Using FutureTask to preload data that is needed later
*
* @author Brian Goetz and Tim Peierls
*/
public class Preloader {
ProductInfo loadProductInfo() throws DataLoadException {
return null;
}
private final FutureTask future =
new FutureTask(new Callable() {
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 instanceof DataLoadException)
throw (DataLoadException) cause;
else
throw LaunderThrowable.launderThrowable(cause);
}
}
interface ProductInfo {
}
}
package net.jcip.examples;
/**
* StaticUtilities
*
* @author Brian Goetz and Tim Peierls
*/
public class LaunderThrowable {
/**
* Coerce an unchecked Throwable to a RuntimeException
*
* If the Throwable is an Error, throw it; if it is a
* RuntimeException return it, otherwise throw IllegalStateException
*/
public static RuntimeException launderThrowable(Throwable t) {
if (t instanceof RuntimeException)
return (RuntimeException) t;
else if (t instanceof Error)
throw (Error) t;
else
throw new IllegalStateException("Not unchecked", t);
}
}
信号量(Semaphore）
介绍
- Semaphore管理者一组虚拟许可(permit），许可数量可以通过构造函数来指定。
- 在执行操作前需要通过acquire获得许可，acquire将阻塞直到有许可或者被中断或操作超时。
- release方法释放一个许可给型号量。
作用
计数器信号量用（Counting Semaphore）来控制同时访问某个特定资源的操作数量，计数器信号量还可以用来实现某种资源池，或对容器加边界。
案例：使用信号量将Set容器变成有界阻塞容器。
package net.jcip.examples;
import java.util.*;
import java.util.concurrent.*;
/**
* BoundedHashSet
*
* Using Semaphore to bound a collection
*
* @author Brian Goetz and Tim Peierls
*/
public class BoundedHashSet {
private final Set set;
private final Semaphore sem;
public BoundedHashSet(int bound) {
this.set = Collections.synchronizedSet(new HashSet());
sem = new Semaphore(bound);
}
public boolean add(T o) throws InterruptedException {
sem.acquire();
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;
}
}
栅栏
介绍
- 闭锁是一次性对象，一旦进入终止状态就不能被重置，而栅栏可以重置，等待下一次使用。
- 类似于闭锁，都能阻塞一组线程到某个事件发生。区别：闭锁用于等待事件（计数器清零事件），而栅栏用于等待其他线程。
- 栅栏常用于协议，比如几个家庭决定在某个地方集合：“所有人8点在麦当劳碰头，到了以后等其他人，之后再讨论下一步事情”
Java实现
实现类CyclicBarrier和Exchanger。
Exchanger是一种两方栅栏，各方在栅栏位置上交换数据。（不太懂，待学习）
下面讲CyclicBarrier。
可以使一定数量的线程方反复（栅栏可重用）在栅栏位置汇集，在并行迭代算法中非常有用。数量在构造方法中设置。
一个线程到达栅栏位置时将调用线程的await方法，这个方法会阻塞知道所有线程都到栅栏位置。
所有线程到达栅栏后，栅栏打开，线程被释放，而栅栏被重置下次使用。
对await调用超时、或await阻塞的线程被中断，那么栅栏就被认为是打破了，所有阻塞的await调用都将终止并抛出BrokenBarrierException。
*成功通过栅栏，那么await将为每个线程返回一个唯一的到达索引号，我们可以用这些索引来“选举”产生一个领导线程，并在下一个迭代中由该线程执行一些特殊任务。当成功通过栅栏时，可以对栅栏执行一个Runnable操作（可选），该操作通过构造函数传递。
举栗子：4个人盖3层房子，前提要想盖第二层必须要等第一层四侧都盖好才可以进行。为提高并行度每个人盖一侧，当所有人都盖完当前层一侧后，盖上楼板开始盖第二层，直到盖完。所以这里涉及到并行和迭代问题，每次迭代前都要等4个人都盖完当前楼层的一侧，这里的盖上楼板就是汇总四个人的结果。
案例
- 计算细胞的自动化模拟，将细胞分成N分，并分配N个线程进行处理，所有都处理完后，对结果进行汇总，汇总完后可开始下一步计算。其中N是cpu的数量。
package net.jcip.examples;
import java.util.concurrent.*;
/**
* CellularAutomata
*
* Coordinating computation in a cellular automaton with CyclicBarrier
*
* @author Brian Goetz and Tim Peierls
*/
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;
}
}
}
private int computeValue(int x, int y) {
// Compute the new value that goes in (x,y)
return 0;
}
}
public void start() {
for (int i = 0; i < workers.length; i++)
new Thread(workers[i]).start();
mainBoard.waitForConvergence();
}
interface Board {
int getMaxX();
int getMaxY();
int getValue(int x, int y);
int setNewValue(int x, int y, int value);
void commitNewValues();
boolean hasConverged();
void waitForConvergence();
Board getSubBoard(int numPartitions, int index);
}
}
- 补充：TinkerPop3中每个Worker处理VertexProgram就是采用栅栏
GraphComputer
image.png