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号选手 起跑！
同步辅助类----------------------------------------------同步辅助类----------------------------------------------同步辅助类--------------
