jdk线程池，使用手记

Executors----------------------------------------------Executors----------------------------------------------Executors--------------

为了更好的控制多线程，JDK提供了一套线程框架Executor，帮助开发人员有效的进行线程控制。它们都在java.util.concurrent包中，是JDK并发包的核心。
其中有一个比较重要的类:Executors，他扮演着线程工厂的角色，我们通过Executors可以创建特定功能的线程池。
Executors创建线程池方法：
　　newFixedThreadPool()；该方法返回一个固定数量的线程池，该方法的线程数始终不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有，
　　　　则会被暂缓在一个任务队列中，等待有空闲的线程去执行。

　　newSingleThreadExecutor();创建一个线程的线程池，若空闲则执行，若没有空闲线程则暂缓在任务队列中。

　　newCachedThreadPool();返回一个可根据实际情况调整线程个数的线程池，不限制最大线程数量，若用空闲的线程则执行任务，若无任务则不创建线程。
　　　　并且每一个空闲线程会在60秒后自动回收。

　　newScheduledThreadPool();该方法返回一个SchededExecutorService对象，类似于第一个方法,但该线程池可以指定线程的数量。

//创建出容量为10的线程池

ExecutorService pool = Executors.newFixedThreadPool(10);

//表示创建了容量为1的线程池
ExecutorService pool2 = Executors.newSingleThreadExecutor();
//创建容量没有限制的线程池
ExecutorService pool3 = Executors.newCachedThreadPool();
//创建固定数量的线程池（指定数量）   底层使用带有延迟和周期性的执行任务机制
ScheduledExecutorService pool4 = Executors.newScheduledThreadPool(10); 

分析底层实现：

newFixedThreadPool(10);

/**
 * @param nThreads:核心线程
 * @return
 *  new ThreadPoolExecutor
 *      @param nThreads 核心线程（线程池被实例化后，其内部直接初始化了"nThreads"个线程）
 *      @param nThreads 最大线程数
 *      @param 0L 当前线程空闲时间为0
 *      @param TimeUnit.MILLISECONDS 该线程空闲时间单位（秒、小时...）
 *      @param new LinkedBlockingQueue<Runnable>() (一种无界队列类型)的存储器，如果池子没有空闲的话，新的线程将会被载入到该队列中
 */
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>());
}

newSingleThreadExecutor();

/**
 * @return
 *   new FinalizableDelegatedExecutorService
 *     ThreadPoolExecutor
 *       @param 1 默认在池子里创建一个线程
 *       @param 1 池子默认大小为1
 *       @param 0L 当前线程空闲时间为0
 *       @param TimeUnit.MILLISECONDS 该线程空闲时间单位（秒、小时...）
 *       @param new LinkedBlockingQueue<Runnable>() (一种无界队列类型)的存储器，如果池子没有空闲的话，新的线程将会被载入到该队列中
 */
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>()));
}

newCachedThreadPool();

/**
 * @return
 *  new ThreadPoolExecutor
 *    @param 0 初始化该线程池的时候默认不创建线程
 *    @param Integer.MAX_VALUE 默认该池子的大小为 MAX_VALUE (即不限制大小)
 *    @param 0 初始化该线程池的时候默认不创建线程
 *    @param TimeUnit.MILLISECONDS 该线程空闲时间单位（秒、小时...）
 *    @param new SynchronousQueue<Runnable>())阻塞队列，用于存储等待的任务

 */

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
            60L, TimeUnit.SECONDS,
            new SynchronousQueue<Runnable>());
}

Executors----------------------------------------------Executors----------------------------------------------Executors--------------

同步辅助类----------------------------------------------同步辅助类----------------------------------------------同步辅助类--------------

CountDownLatch  在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待； 
   使用场景：常用语监听某些初始化操作，等初始化执行完毕后，通知主线程继续工作。

　　构造方法参数指定了计数的次数

　　countDown方法，当前线程调用此方法，则计数减一

　　await方法，调用此方法会一直阻塞当前线程，直到计时器的值为0

 public class CountDownLatchDemo {
     final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     public static void main(String[] args) throws InterruptedException {
         CountDownLatch latch=new CountDownLatch();//两个工人的协作
         Worker worker1=new Worker("zhang san", , latch);
         Worker worker2=new Worker("li si", , latch);
         worker1.start();//
         worker2.start();//
         latch.await();//等待所有工人完成工作
         System.out.println("all work done at "+sdf.format(new Date()));
     }

     static class Worker extends Thread{
         String workerName;
         int workTime;
         CountDownLatch latch;
         public Worker(String workerName ,int workTime ,CountDownLatch latch){
              this.workerName=workerName;
              this.workTime=workTime;
              this.latch=latch;
         }
         public void run(){
             System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date()));
             doWork();//工作了
             System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date()));
             latch.countDown();//工人完成工作，计数器减一

         }

         private void doWork(){
             try {
                 Thread.sleep(workTime);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

 }

输出：

Worker zhang san do work begin at 2011-04-14 11:05:11
Worker li si do work begin at 2011-04-14 11:05:11
Worker zhang san do work complete at 2011-04-14 11:05:16
Worker li si do work complete at 2011-04-14 11:05:19
all work done at 2011-04-14 11:05:19

CyclicBarrier 它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，
　　这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。      

使用场景：需要所有的子任务都完成时，才执行主任务，这个时候就可以选择使用CyclicBarrier。
method：

await
public int await()
          throws InterruptedException,
                 BrokenBarrierException
在所有参与者都已经在此 barrier 上调用 await方法之前，将一直等待。如果当前线程不是将到达的最后一个线程，出于调度目的，将禁用它，且在发生以下情况之一前，该线程将一直处于休眠状态：
最后一个线程到达；或者
其他某个线程中断当前线程；或者
其他某个线程中断另一个等待线程；或者
其他某个线程在等待 barrier 时超时；或者
其他某个线程在此 barrier 上调用 reset()。
如果当前线程：
在进入此方法时已经设置了该线程的中断状态；或者
在等待时被中断
则抛出 InterruptedException，并且清除当前线程的已中断状态。如果在线程处于等待状态时 barrier 被 reset()，或者在调用 await 时 barrier 被损坏，抑或任意一个线程正处于等待状态，
则抛出 BrokenBarrierException 异常。
如果任何线程在等待时被 中断，则其他所有等待线程都将抛出 BrokenBarrierException 异常，并将 barrier 置于损坏状态。
如果当前线程是最后一个将要到达的线程，并且构造方法中提供了一个非空的屏障操作，则在允许其他线程继续运行之前，当前线程将运行该操作。如果在执行屏障操作过程中发生异常，
则该异常将传播到当前线程中，并将 barrier 置于损坏状态。

返回：
到达的当前线程的索引，其中，索引 getParties() - 1 指示将到达的第一个线程，零指示最后一个到达的线程
抛出：
InterruptedException - 如果当前线程在等待时被中断
BrokenBarrierException - 如果另一个 线程在当前线程等待时被中断或超时，或者重置了 barrier，或者在调用 await 时 barrier 被损坏，抑或由于异常而导致屏障操作（如果存在）失败。

　　

 public class CyclicBarrierTest {  

     public static void main(String[] args) throws IOException, InterruptedException {
         //如果将参数改为4，但是下面只加入了3个选手，这永远等待下去
         //Waits until all parties have invoked await on this barrier.
         CyclicBarrier barrier = new CyclicBarrier();  

         ExecutorService executor = Executors.newFixedThreadPool();
         executor.submit(new Thread(new Runner(barrier, "1号选手")));
         executor.submit(new Thread(new Runner(barrier, "2号选手")));
         executor.submit(new Thread(new Runner(barrier, "3号选手")));  

         executor.shutdown();
     }
 }  

 class Runner implements Runnable {
     // 一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)
     private CyclicBarrier barrier;  

     private String name;  

     public Runner(CyclicBarrier barrier, String name) {
         super();
         this.barrier = barrier;
         this.name = name;
     }  

     @Override
     public void run() {
         try {
             Thread.sleep( * (new Random()).nextInt());
             System.out.println(name + " 准备好了...");
             // barrier的await方法，在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。
             barrier.await();
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (BrokenBarrierException e) {
             e.printStackTrace();
         }
         System.out.println(name + " 起跑！");
     }
 }  

输出：

3号选手 准备好了...
2号选手 准备好了...
1号选手 准备好了...
1号选手 起跑！
2号选手 起跑！
3号选手 起跑！

同步辅助类----------------------------------------------同步辅助类----------------------------------------------同步辅助类--------------