JAVA为我们提供了一些效果非常不错的并发工具类，这里主要介绍一下如下几个工具类的使用，并不会去深究实现原理（其实原理都是通过自旋CAS,CAS对应的处理器原子操作指令是CMPXCHG）。

Semaphore
CountDownLatch
CyclicBarrier
Executors

一、Semaphore

1、作用

设定信号量，只有获得信号量的线程才能够往后执行业务逻辑，没有获得信号量的线程只能阻塞等待唤醒重新尝试获得信号量,可用于服务限流。

2、代码示例

/**
 * Semaphore作用：设定信号量，只有获得信号量的线程才能够往后执行业务逻辑，
 * 没有获得信号量的线程只能阻塞等待唤醒重新尝试获得信号量,可用于服务限流
 * @author 爱吃鱼的乌贼
 */
public class SemaphoreTest {

    public static void main(String[] args) {
        //设定信号量，只允许2个线程同时处理
        Semaphore semaphore = new Semaphore(2);
        for(int i=0;i<10;i++) {
            new Thread(new Runnable() {
                public void run() {
                    try {
                        //获取信号量
                        semaphore.acquire();
                        System.out.println("Thread："+Thread.currentThread().getId()+"获得信号量"+new Date());
                        Thread.sleep(5000);
                        System.out.println("Thread："+Thread.currentThread().getId()+"释放信号量"+new Date());
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

}

二、CountDownLatch

1、作用

能够使一个线程等待其他线程完成各自的工作后再执行

2、代码示例

/**
 * CountDownLatch 能够使一个线程等待其他线程完成各自的工作后再执行
 * @author 爱吃鱼的乌贼
 */
public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Task1(countDownLatch).start();
        new Task2(countDownLatch).start();
        countDownLatch.await();
        System.out.println("起锅烧油");
    }
    public static  class Task1 extends Thread{
        CountDownLatch countDownLatch;
        public Task1(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            System.out.println("正在洗菜中....");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("菜已洗好!");
            countDownLatch.countDown();
        }
    } 
    public static class Task2 extends Thread{
        CountDownLatch countDownLatch;
        public Task2(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }
        @Override
        public void run() {
            System.out.println("正在煮饭中....");
            try {
                Thread.sleep(6000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("饭已煮好!");
            countDownLatch.countDown();
        }
    } 

}

三、CyclicBarrier

1、作用

栅栏屏障，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。

2、代码示例

/**
 *  CyclicBarrier 栅栏屏障，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，
 * 直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。
 * @author 爱吃鱼的乌贼
 */
public class CyclicBarrierTest {

    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier =new CyclicBarrier(10);
        for(int i=0;i<10;i++) {
            new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(new Random().nextInt(1000)+1000);
                        System.out.println("Thread："+Thread.currentThread().getId()+"已经准备好");
                        cyclicBarrier.await();
                        System.out.println("Thread："+Thread.currentThread().getId()+"开始出发");
                    } catch (Exception e) {
                                e.printStackTrace();
                    }
                }
            }).start();
        }

    }

}

四、Executors

1、作用

主要用来创建线程池，代理了线程池的创建，使得你的创建入口参数变得简单

• newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
• newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
• newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
• newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO,LIFO, 优先级)执行。

2、代码示例

/**
 * Executors:主要用来创建线程池，代理了线程池的创建，使得你的创建入口参数变得简单
 * @author 爱吃鱼的乌贼
 */
public class ExecutorsTest {

    public static void main(String[] args) {
        // 1、newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    // 这里会发现结果有重复的线程ID
                    System.out.println("Thread:" + Thread.currentThread().getId() + ";newCachedThreadPool");
                }
            });
        }

        // 2、newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 10; i++) {
            newFixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // 这里会发现两个两个执行完后才继续执行,并且线程ID不变
                    System.out.println("Thread:" + Thread.currentThread().getId() + ";newFixedThreadPool");
                }
            });
        }

        // 3、newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(2);
        // 延迟3秒钟后执行任务
        newScheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("运行时间: " + new Date());
            }
        }, 3, TimeUnit.SECONDS);

        // 延迟1秒钟后每隔3秒执行一次任务
        newScheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("运行时间: " + new Date());
            }
        }, 1, 3, TimeUnit.SECONDS);


        // 4、newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            newSingleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    // 这里会发现结果有重复的线程ID
                    System.out.println("Thread:" + Thread.currentThread().getId() + ";newSingleThreadExecutor");
                }
            });
        }
    }
}