并发包（Concurrent包）中含有的类有哪些？
ConcurrentHashMap / CopyOnWriteArrayList
阻塞队列
同步辅助类
线程池相关的类
Lock接口
原子类
同步辅助类
1）CountDownLatch：闭锁
它就相当于一个计数器。用一个给定的数值初始化CountDownLatch，之后计数器就从这个值开始倒计数，知道计数值达到0。
CountDownLatch是通过"共享锁"实现的。在创建CountDownLatch时，会传递一个int类型参数，该参数是"锁计数器"的初始状态，表示该"共享锁"最多能被count个线程同时获取，这个值只能被设置一次，而且CountDownLatch没有提供任何机制去重新设置这个计数值。主线程必须在启动其他线程后立即调用await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。当某线程调用该CountDownLatch对象的await()方法时，该线程会等待"共享锁"可用时，才能获取"共享锁"进而继续运行。而"共享锁"可用的条件，就是"锁计数器"的值为0！而"锁计数器"的初始值为count，每当一个线程调用该CountDownLatch对象的countDown()方法时，才将"锁计数器"-1；通过这种方式，必须有count个线程调用countDown()之后，"锁计数器"才为0，而前面提到的等待线程才能继续运行！
3个重要的函数：
//作用是让线程阻塞等待其他线程，直到CountDownLatch的计数值变为0，才继续执行之后的操作。
public void await() throws InterruptedException {};
//和await()类似，只不过等待⼀定的时间后count值还没变为0的话就会继续执⾏
public boolean await(long timeout, TimeUnit unit) throws InterruptedException
{}
//这个函数用来将CountDownLatch的计数值-1，如果技术达到0，则释放所有等待的线程。
public void countDown() {};图示：
它的应用场景：
一个任务，它需要等待其他的一些任务都执行完毕之后它才能继续执行。
比如：开5个多线程去下载，当5个线程都执行完了才算下载成功。
对于倒计数器，一种典型的场景就是火箭发射，在火箭发射前，为了保证万无一失，往往还需要进行各项设备、仪器的检测。只有等到所有的检查完毕后，引擎才能点火。那么在检测环节当然是多个检测项可以同时进行的。代码实现：
public class CountDownLatchDemo implements Runnable{
static final CountDownLatch latch = new CountDownLatch(10);
static final CountDownLatchDemo demo = new CountDownLatchDemo();
@Override
public void run() {
//模拟检查任务
try {
Thread.sleep(new Random().nextInt(10) * 1000);
System.out.println("check complete");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//计数减一
//放在finally避免任务执行过程出现异常，导致countDown()不能被执行
latch.countDown();
}
}
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10;i++){
exec.submit(demo);
}
//等待检查
latch.await();
//发射火箭
System.out.println("Fire!!!");
//关闭线程池
exec.shutdown();
}
}
上述代码中，我们先生成了一个CountDownLatch实例。计数数量为10，这表示需要有10个线程来完成任务，等待在CountDownLatch上的线程才能继续执行。latch.countDown()；方法作用是通知CountDownLatch有一个线程已经准备完毕，倒计数器可以减一了。latch.await()方法要求主线程等待所有10个检查任务全部准备好才一起并行执行。
2）CyclicBarrier：循环栅栏
通过它可以实现让⼀组线程等待⾄某个状态之后再全部同时执⾏。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重⽤。我们暂且把这个状态就叫做barrier，当调⽤await()⽅法之后，线程就处于barrier了。
CyclicBarrier提供2个构造器：
public CyclicBarrier(int parties, Runnable barrierAction) {}
public CyclicBarrier(int parties) {}参数parties指让多少个线程或者任务等待⾄barrier状态；参数barrierAction为当这些线程都达到 barrier状态时会执⾏的内容。
CyclicBarrier中最重要的⽅法就是await⽅法，它有2个重载版本：
public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit) throws InterruptedException,BrokenBarrierException,TimeoutException { };第⼀个版本⽐较常⽤，⽤来挂起当前线程，直⾄所有线程都到达barrier状态再同时执⾏后续任务；
第⼆个版本是让这些线程等待⾄⼀定的时间，如果还有线程没有到达barrier状态就直接让到达barrier 的线程执⾏后续任务。
await()函数每调用一次，计数器便会减少1（CyclicBarrier设置了初始值）。并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此CyclicBarrier上面阻塞的线程开始运行。
图示:
代码示例：
public class CyclicBarrierDemo {
static class TaskThread extends Thread {
CyclicBarrier barrier;
public TaskThread(CyclicBarrier barrier) {
this.barrier = barrier;
}
@Override
public void run() {
try {
Thread.sleep(1000);
System.out.println(getName() + "到达栅栏 A");
barrier.await();
System.out.println(getName() + "冲破栅栏 A");
Thread.sleep(2000);
System.out.println(getName() + "到达栅栏 B");
barrier.await();
System.out.println(getName() + "冲破栅栏 B");
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
int threadNum = 5;
CyclicBarrier barrier = new CyclicBarrier(threadNum, new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "完成最后的任务");
}
});
for (int i = 0; i < threadNum; i++) {
new TaskThread(barrier).start();
}
}
}从执行结果中可以看出，所有线程会等待全部线程到达栅栏之后才会继续执行，并且最后到达的线程会完成Runnable的任务。
CountDownLatch和CyclicBarrier的区别？
1）CountDownLatch的作用是允许1个线程等待其他线程执行完成之后，它才执行；而CyclicBarrier则是允许N个线程相互等待到某个公共屏障点，然后这一组线程再同时执行。
2）CountDownLatch的计数器的值无法被重置，这个初始值只能被设置一次，是不能够重复使用的；CyclicBarrier是可以重用的。
3）Semaphore：信号量
可以控制某个资源可被同时访问的个数，通过构造函数设定一定数量的许可，通过acquire()获取一个许可，如果没有就等待，而release()释放一个许可。
Semaphore类提供了2个构造器：
//参数permits表示许可数⽬，即同时可以允许多少线程进⾏访问
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
//这个多了⼀个参数fair表示是否是公平的，即等待时间越久的越先获取许可
public Semaphore(int permits, boolean fair) {
sync = (fair) ? new FairSync(permits) : new NonfairSync(permits);
}Semaphore类中⽐较重要的⼏个⽅法，⾸先是acquire()、release()⽅法：
//获取⼀个许可
public void acquire() throws InterruptedException { }
//获取permits个许可
public void acquire(int permits) throws InterruptedException { }
//释放⼀个许可
public void release() { }
//释放permits个许可
public void release(int permits) { }acquire()⽤来获取⼀个许可，若⽆许可能够获得，则会⼀直等待，直到获得许可。
release()⽤来释放许可。注意，在释放许可之前，必须先获获得许可。
图示:
代码实现：
public class SemaphoreTest {
public static void main(String[] args) {
//线程池
ExecutorService exec = Executors.newCachedThreadPool();
//只能5个线程同时访问
final Semaphore semp = new Semaphore(5);
//模拟20个客户端访问
for (int index = 0; index < 20;index++){
final int NO = index;
Runnable run = new Runnable() {
@Override
public void run() {
try {
semp.acquire();
System.out.println("Accessing: " + NO);
Thread.sleep((long) (Math.random() * 1000));
//访问完后，释放，如果屏蔽下面的语句，则在控制台只能打印5条记录，之后线程一直阻塞
semp.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
exec.execute(run);
}
//退出线程池
exec.shutdown();
}
}