多线程高级的工具

java.util.concurrent中更高级的工具分成三类：

Executor Framework
并发集合(Concurrent Collection)
同步器(Synchronizer)


一、executor和task优先于线程：

在Java 1.5 中提供了java.util.concurrent包，在这个包中包含了Executor Framework框架，
这是一个很灵活的基于接口的任务执行工具。该框架提供了非常方便的调用方式和强大的功能，
如：
//创建一个单线程执行器对象。
ExecutorService executor = Executors.newSingleThreadExecutor();

//提交一个待执行的任务。
executor.execute(runnable);
//使执行器优雅的终止。
executor.shutdown();

事实上，Executors对象还提供了更多的工厂方法，

如适用于小型服务器的：Executors.newCachedThreadPool()工厂方法
该方法创建的执行器实现类对于小型服务器来说还是比较有优势的，
因为在其内部实现中并没有提供任务队列，而是直接将任务提交给当前可用的线程，
如果此时没有可用的线程了，则创建一个新线程来执行该任务。
因此在任务数量较多的大型服务器上，由于该机制创建了大量的工作者线程，
这将会导致系统的整体运行效率下降。对于该种情况，
Executors提供了另外一个工厂方法Executors.newFixedThreadPool()，
该方法创建的执行器实现类的内部提供了任务队列，用于任务缓冲。
相比于java.util.Timer，该框架也提供了一个更为高效的执行器实现类，
通过工厂方法Executors.ScheduledThreadPool()可以创建该类。
它提供了更多的内部执行线程，这样在执行耗时任务是，其定时精度要优于Timer类。

-------------------------------------------

二、并发工具优先于wait和notify：

对于同步器，concurrent包中给出了四种主要的同步器对象：
CountDownLatch、Semaphore、CyclicBarrier和Exchanger。
这里前两种比较常用。在该条目中我们只是简单介绍一个CountDownLatch的优势。

使用场景：

该类允许一个或者多个线程等待一个或者多个线程来做某些事情。

CountDownLatch的唯一构造函数带有一个int类型的参数 ，
这个int参数是指允许所有在等待的线程被处理之前，必须在锁存器上调用countDown方法的次数。

代码如下：

package countDownLatch_test;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

import threadPool.executorDemo.RejectedTaskController;
/**
 * 
 * 同步器对象：CountDownLatch
 * 并发工具优先于wait和notify
 */
public class Driver {
    
    /**
     * 工作线程数
     */
    private static final int WORK_NUM = 5;
    
    public static void main(String[] args) {
        
        //参数 1 为倒计数次数，即startSignal.countDown() 1 次，startSignal.await()倒计数为0,线程释放
        CountDownLatch startSignal = new CountDownLatch(1);
        
        //参数 5 为倒计数次数，即需要doneSignal.countDown()的次数，doneSignal.await()倒计数为0,线程释放
        CountDownLatch doneSignal = new CountDownLatch(WORK_NUM);
        
        //创建一个拥有5个线程的线程池
        ThreadPoolExecutor exe = (ThreadPoolExecutor)Executors.newFixedThreadPool(WORK_NUM);
        
        //添加线程池关闭后出现的异常处理
        exe.setRejectedExecutionHandler(new RejectedTaskController());
        
        for (int i = 0; i < 5; ++i) {
            //在未来某个时间执行给定的命令
            exe.execute(new Worker(i, startSignal, doneSignal));
        }
        
        //在工作线程未启动前做一些事前准备
        doSomethingElse();
        
        //倒数一次，startSignal.await()倒计数为0,线程释放
        startSignal.countDown();
        
        try {
            //等待工作线程全部完毕，也就是doneSignal.countDown()为5次
            doneSignal.await();
            //工作线程完毕后的事后处理
            doSomethingElse();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            //顺序关闭
            exe.shutdown();
        }
    }
    
    private static void doSomethingElse() {
        System.out.println("doSomethingElse.....");
    }
}

package countDownLatch_test;

import java.util.concurrent.CountDownLatch;

public class Worker implements Runnable{
    
    /**
     * 工作编号
     */
    private int id;
    
    private final CountDownLatch startSignal;
    
    private final CountDownLatch doneSignal;
    
    public Worker(int id ,CountDownLatch startSignal, CountDownLatch doneSignal) {
        this.id = id;
        this.startSignal = startSignal;
        this.doneSignal = doneSignal;
    }
    
    public void run() {
        try {
            //等待倒数到0，如果没有到达0，就阻塞等待
            startSignal.await();
            doWork();
            //倒数一次
            doneSignal.countDown();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        } 
    }
    
    private void doWork() {
        System.out.println("工作 ："+id+"  doWork ...."); 
    }
    
}
public class RejectedTaskController implements RejectedExecutionHandler {
    
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        
        //打印线程信息
        System.out.printf("RejectedTaskController: The task %s has been rejected\n", r.toString());
        
        //打印线程池信息
        System.out.printf("RejectedTaskController: %s\n", executor.toString());
        
        //如果此执行程序处于在 shutdown 或 shutdownNow 之后正在终止但尚未完全终止的过程中，则返回 true
        System.out.printf("RejectedTaskController: Terminating: %s\n", executor.isTerminating());
        
        //如果关闭后所有任务都已完成，则返回 true
        System.out.printf("RejectedTaksController: Terminated: %s\n", executor.isTerminated());
    }
}

----------------------------------------------

三 并发集合；
相比于java.util中提供的集合类，java.util.concurrent中提供的并发集合就有更好的并发性，
其性能通常数倍于普通集合，如ConcurrentHashMap等。
换句话说，除非有极其特殊的原因存在，否则在并发的情况下，一定要优先选择ConcurrentHashMap，
而不是Collections.syschronizedmap或者Hashtable。
java.util.concurrent包中还提供了阻塞队列，
该队列极大的简化了生产者线程和消费者线程模型的编码工作。