在JDK 1.5之前，提到并发，java程序员们一般想到的是wait()、notify()、Synchronized关键字等，但是并发除了要考虑竞态资源、死锁、资源公平性等问题，往往还需要考虑性能问题，在一些业务场景往往还会比较复杂，这些都给java coder们造成不小的难题。JDK 1.5的concurrent包帮我们解决了不少问题。
Concurrent包中包含了几个比较常用的并发模块，这个系列，LZ就和大家一起来学习各个模块，Let’s Go!
一、线程池的基本用法
一般并发包里有三个常用的线程池实例化方法，在Executors这个工厂类中。
- ·newFixedThreadPool(int size):
创建一个可重用固定线程数的线程池，以共享的无界队列（LinkedBlockingQueue）方式来运行这些线程。任何时刻最多只有size大小的线程在执行各自任务。当线程池中所有线程都在运行，后续新来的线程将在无界队列中等待，直到有空闲线程为止。如果有线程在执行任务期间终止退出，一个新的线程会替代原先的线程继续后面任务的执行。线程池中的线程会一直存在，除非显示的关闭某个线程。
ExecuterService fixedPool = Executors. newFixedThreadPool(5); //创建一个固定包含5个线程的线程池
- ·newCachedThreadPool()
创建一个可以根据需要创建线程的线程池，当一个任务过来，如果线程池中有空闲可用线程，先用空闲线程，没有就创建一个新线程。这种线程池对于执行short-lived asynchronous tasks（短期异步任务）通常会提高性能。默认空闲60s的线程会从线程池中移除，如果长时间空闲的话，这个线程池是不会占用任何资源的。但是以我个人的经验，这种线程池要慎用，用不好经常会造成堆外内存溢出，从而造成应用反应慢，最后导致宕机。
ExecuterService fixedPool = Executors. newCachedThreadPool();
- ·newSingleThreadExecutor()
创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。可以保证顺序执行各个任务。有人说这不就是newFixedThreadPool(1)么，错矣。看源码就知道外部还包了一层FinalizableDelegatedExecutorService，这个是Executors的一个静态内部类，这个内部类继承了DelegatedExecutorService，返回的这个ExecutorService实现只包含ExecutorService接口定义的一些方法，不同于newFixedThreadPool有自己扩展的方法。源码注释的区别是：newSingleThreadExecutor可以保证使用其他线程时，返回的Executor不用重新配置。
ExecuterService fixedPool = Executors. newSingleThreadExecutor();
- ·newScheduledThreadPool(int size)
创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。这是个无界大小的线程池。其中主要的执行方法是scheduleAtFixedRate和scheduleWithFixedDelay方法，最终的核心方法是delayedExecute，这两个方法有什么区别呢，简单来说，scheduleAtFixedRate是以任务执行时间开始为延迟时间起点的，scheduleWithFixedDelay是以任务执行结束时间为延时时间起点的。
接下来对并发包里面常用的一些类进行使用解析
1） 信号量 Semaphore:
一个计数信号量，维护了一个许可集。通俗的讲，就是对有限共享资源记录使用情况。
举个日常生活中的例子好了：有20个人去登记信息表格，但是只有3只笔，一个人用完之后给下面一个人用，直到所有人都用完。
没有并发包之前，我们是怎么设计的呢?
定义一个变量a，用synchronized修饰，值为3，新建20个线程模拟20个人访问，每个人用笔之前，先看是否有空余的笔，如果有，就使用，并将变量a减少1，使用完成之后，再放回去，即将变量a加1，各个线程之间对于变量a的访问需要互斥进行。Synchronized是一个重量级的同步操作，涉及到用户态与核心态的切换，所以性能一般。
让我们再看看信号量是怎么实现的，Semaphore实现的思想跟上面差不多。只不过Semaphore已经帮我们做了同步处理，有两个关键的方法：
- ·acquire() 获取一个信号量许可
- ·release() 释放一个信号量许可
此外还有其他一些方法：availablePermits() 返回信号量可用的许可数，talk is cheap show me the code：
public class SemaphoreTest extends Thread{
private String name;
private Semaphore sh;
public SemaphoreTest(String name,Semaphore sh){
this.name = name;
this.sh = sh;
}
public void run(){
if(sh.availablePermits()>0){
System.out.println("有笔");
}else{
System.out.println("笔没了，等等");
}
try {
sh.acquire();//信号量减1
System.out.println(this.name+"号在用笔");
Thread.sleep((long) (Math.random()*1000));
sh.release();
System.out.println(this.name+"号用完了");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) {
ExecutorService es = Executors.newCachedThreadPool();
Semaphore sh = new Semaphore(3);
for(int i=0;i<20;i++){
es.submit(new SemaphoreTest(i+"",sh));
}
es.shutdown();
}
}
上述代码直接运行即可。
这个信号量是如何同步资源的，就需要读读jdk相关源码了。核心类是AbstractQueuedSynchronizer，该类实现了一个FIFO的列表，列表中Node表示列表节点，该Node有prev、next、Thread等属性，表示前节点后节点以及线程等。并发包中每个需要实现个性化同步机制的都要扩展该类，以实现不同的同步功能。比如Semaphore、countDownLatch、CyclicBarrier等，具体原理要分析源码，篇幅较长，这里不做展开，有兴趣的可以研究一下，对volatile关键字、CAS等都会有更深的理解。
2） CountDownLatch
用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。
比较重要的2个方法：countDown()和await()
下面来个常见的例子：导游带了20人团到了饭店吃饭，要等到20个人到齐了，才开始吃饭，还要等到20人都吃完了，才可以继续下个景点。
来看看不用并发包你会怎么实现，首先会设置20个人到来以及吃完的标志，每个线程过来更改自己的标志，主程序for或者while不停的循环监听，制止全部到来以及吃完才继续。如果是100人1000人呢，未免臃肿。
CountDownLatch的实现：
public class CountDownLautchTest {
public static void main(String[] args) {
ExecutorService es = Executors.newFixedThreadPool(20);
final CountDownLatch endFlag = new CountDownLatch(20);
final CountDownLatch startFlag = new CountDownLatch(1);
final CountDownLatch comeFlag = new CountDownLatch(20);
for(int i=0;i<20;i++){
final int j = i + 1;
Runnable person = new Runnable(){
@Override
public void run() {
System.out.println(j+"号游客来了");
comeFlag.countDown();
try {
startFlag.await();
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
System.out.println(j+"号吃完了");
endFlag.countDown();
}
}
};
es.submit(person);
}
try {
comeFlag.await(); //保证所有人都到齐了
System.out.println("人都齐了，大家一起吃饭");
startFlag.countDown();//开吃
endFlag.await();//等待所有人都吃完了
System.out.println("全都吃完了，继续下个景点");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
es.shutdown();
}
}
CountDownLatch是一种不可逆的降序计数操作，所以上述代码里面定义了2个分别表示等候以及吃饭的标志。如果需要重复计数，就需要用到下面这个类：CyclicBarrier。
3） CyclicBarrier
一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。
还是上述的例子吧，再加一点场景，吃完饭还要游玩，游玩结束返程回家。让我们来看看CyclicBarrier是如何实现的，上代码：
public class CyclicBarrierTest {
public static void main(String[] args) {
final CyclicBarrier barrier = new CyclicBarrier(20);
final ExecutorService es = Executors.newFixedThreadPool(20);
System.out.println("****等人齐****");
for(int i=0;i<20;i++){
final int j = i+1;
Runnable person = new Runnable(){
@Override
public void run() {
try {
System.out.println(j+"号来了");
if(barrier.await()==0){
System.out.println("****人都到齐了****");
}
System.out.println(j+"号开吃");
if(barrier.await()==0){
System.out.println("****吃完了出发****");
}
System.out.println(j+"号玩好了");
if(barrier.await()==0){
System.out.println("****游玩结束回家****");
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
es.submit(person);
}
es.shutdown();
}
}
代码直接运行即可，应该比较好懂吧，这里有个小窍门，代码中if(barrier.await()==0)这个条件，有点类似于CountDownLatch的await往下执行的条件了，每次判断都会减1，减到0，即完成所有线程的等待，继续下面的操作。
结语
关于并发包一些常用的类就介绍到这里吧，工作中具体怎么使用要具体分析各个业务场景，选择合适的方法，随机应变，触类旁通吧，后续会介绍一下Lock源码以及实现，涉及AQS的原理等。
未完，待续……