同步工具类

同步工具类可以是任何一个对象，只要它根据其自身的状态来协调线程的控制流。

阻塞队列

保存对象的容器， 还能协调生产者和消费者等线程之间的控制流 take和put等方法将阻塞，直到队列达到期望的状态(队列即非空，也非满)。

闭锁

相当于一扇门：在闭锁到达结束状态之前，这扇门一直是关闭的，并且没有任何线程能通过，当到达结束状态时，这扇门会打开并允许所有线程通过。

到达结束状态后，将不会再改变状态，这扇门永远保持打开状态。

CountDownLatch(倒计数锁存器) 是一种灵活的闭锁实现
countDown方法递减计数器
await方法等待计数器达到零，阻塞直到计数器为零或者等待中的线程中断，或者等待超时

使用场景

示例：

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(){                @Override                public void run() {                    try {                        startGate.await();//一直阻塞直到计数器为零                        try {                            task.run();                        }finally {                            endGate.countDown();                        }                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            };            t.start();        }        long start = System.nanoTime();        startGate.countDown();        endGate.await();        long end = System.nanoTime();        return end - start;    }}

FutureTask

也可以用作闭锁。

信号量

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

Semaphore中管理者一组虚拟的许可，在执行操作时可以首先获得许可，并在使用以后释放许可，如果没有许可，那么acquire将阻塞直到有许可(或者直到中断或者操作超时)。

release方法将返回一个许可给信号量，计算信号量的一种简化形式是二值信号量，即初始值为1的Semaphore。二值信号量可以用作互斥体，并具备不可重入的加锁语义：谁拥有这个唯一的许可，谁就拥有了互斥锁。

Semaphore可以用于实现资源池，例如数据库连接池。

使用Semaphore为容器设置边界：

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.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){            System.out.println(Thread.currentThread().getName()+" remove "+o);            sem.release();        }        return wasRemoved;    }}

栅栏

栅栏(Barrier)类似于闭锁，它能阻塞一组线程直到某个事件发生。

闭锁是一次性对象，一旦进入终止状态，就不能被重置。

栅栏与闭锁的关键区别在于，所有的线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待事件，而栅栏用于等待其他线程。

CyclicBarrier可以使一定数量的参与方反复地在栅栏位置汇集，它在并行迭代算法中非常有用：这种算法通常将一个问题拆分成一系列相互独立的子问题。

当线程到达栅栏位置时将调用await方法，这个方法将阻塞直到所有线程都到达栅栏位置。