在工作中想要用Java多线程开发去测试某一个组件，因此Google和阅读了不少文档，在这里做一个总结，希望把1.5之后的多线程框架能够说得明白一点。内容主要包括之Executors,Executor,ExecutorService,CompletionService,Future,CountDownLauch,Callable,Runnable

背景回顾

在讲1.5之后的多线程模式之前，先简单的说一下1.5之前的线程模式，简单的说就是Thread+Runnable模式。Thread是线程，Runnable可以看做是线程要执行的任务。1.5之前的线程模式的一些缺点：

1 管理多线程有诸多不便，比如：多个线程创建，需要多次new Thread；线程生命周期的管理，和多线程同步，需要对Java多线程的实现有比较深入的了解

2 Runnable没有结果返回，需要某种机制等待线程执行结束，通过通知或者回调获取线程执行的结果

Executors线程框架

由于时间关系，UML简化了，这里画出了本人认为最重要的几个类

java多线程集合操作 java多线程集合框架_多线程

类的简要说明

Executors

可以看做是工厂类，主要用于创建和管理Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable

interface ExecutrService

个人觉得看以把ExecutorService看成是多线程的容器，主要用于管理多线程，可以往容器中提交线程，由容器负责线程的生命周期，包括启动，执行，结束线程.  通过上面的类图可以看到我们可以往容器中提交实现Callable或者Runnable接口的类；往容器中提交Callable的实例，将会返回一个Future的对象，这个Future对象可以用于简单的控制Callable对应的线程

interface Callable

跟Runable类似，同样是封装了线程需要的执行任务，执行任务在Callable的call方法中实现，call方法可以看成是Runnable的run方法，唯一不同的是call方法，有一个返回值。我们知道call或者run方法，是由线程框架自己去调用的，那么线程执行结束之后，我们如何获取call方法的返回值呢？我们知道，当往容器中提交Callable实例时，会返回Future类的一个实例。通过Future类的实例，我们可以获取线程结束后(也就是call函数执行完毕)的返回值

interface Future

这个类的基本功能其实在ExecutorService和Callable中已经有提到了，每次往容器中提交Callable或者Runnable任务，都会返回Future的实例；该实例可以简单的管理执行Callable或者Runnable的线程，主要用于获取线程的执行结果，或者查看线程的当前执行状态

interface CompletionService<V>

当我们向容器中提交多个任务时，建设我们提交任务的顺序是task1,task2,task3，我们知道容器是多线程执行任务的，所以任务完成的顺序有可能和任务提交的顺序不一样，比如任务完成的顺序有可能是task2,task1,task3；CompletionService提供了一种机制，可以理解成维护了一个任务完成队列，当容器中有任务完成时，会加入到CompletionService的完成队列中，那么我们通过CompletionService的take 或者 poll方法，每次都能获取剩余任务中，最先执行完的任务

Interface ScheduledExecutorService

用于定时，周期性的执行某一个任务，某些情况下可以代替Timer类

CountDownLatch

这个类在类图中没有画出来，主要用于多线程之间的同步。有点类似Semaphore，当计数值等于0时，将触发事件。

实例

举例1：

Executor executor = Executors.newFixedThreadPool(10);
 Runnable task = new Runnable() {@Override
public void run() {
System.out.println("task executing");
}
};
 executor.execute(task);

 executor = Executors.newScheduledThreadPool(10);
 ScheduledExecutorService scheduler = (ScheduledExecutorService) executor;
 scheduler.scheduleAtFixedRate(task, 10, 10, TimeUnit.SECONDS);

举例2：

/**
 * 内核多线程求和，将数据划分成多个数据块，每个数据块交给一个cpu内核线程去计数和，最后在汇总所有数据的和
 **/
 public class ConcurrentCalculator {private ExecutorService exec;
private CompletionService<Long> completionService;
private int cpuCoreNumber;
class SumCalculator implements Callable<Long> {
private int[] numbers;
private int start;
private int end;
public SumCalculator(final int[] numers, int start, int end) {
this.numbers = numbers;
this.start = start;
this.end = end;
}

public Long call() throws Exception {
Long sum = 0l;
for (int i = start; i < end; i++) {
sum += numbers[i];
}
return sum;
}
}
public ConcurrentCalculator() {
cpuCoreNumber = Runtime.getRuntime().availableProcessors();
exec = Executors.newFixedThreadPool(cpuCoreNumber);
completionService = new ExecutorCompletionService<Long>(exec);
}
public Long sum(final int[] numbers) {
// 根据CPU核心个数拆分任务，创建FutureTask并提交到Executor
for (int i = 0; i < cpuCoreNumber; i++) {
int increment = numbers.length / cpuCoreNumber + 1;
int start = increment * i;
int end = increment * i + increment;
if (end > numbers.length)
end = numbers.length;
SumCalculator subCalc = new SumCalculator(numbers, start, end);
if (!exec.isShutdown()) {
completionService.submit(subCalc);
}
}
return getResult();
}
/**
* 迭代每个只任务，获得部分和，相加返回
* 
* @return
*/
public Long getResult() {
Long result = 0l;
for (int i = 0; i < cpuCoreNumber; i++) {
try {
Long subSum = completionService.take().get();
result += subSum;
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
return result;
}
public void close() {
exec.shutdown();
}
}

举例3：

public class CountDownLatchDemo 
 {private static final int PLAYER_AMOUNT = 5
public CountDownLatchDemo() 
{
// TODO Auto-generated constructor stub    
}
public void test()
{
//对于每位运动员，CountDownLatch减1后即结束比赛
        CountDownLatch begin = new CountDownLatch(1);
        //对于整个比赛，所有运动员结束后才算结束
        CountDownLatch end = new CountDownLatch(PLAYER_AMOUNT);
        Player[] plays = new Player[PLAYER_AMOUNT];
        for(int i=0;i<PLAYER_AMOUNT;i++)
            plays[i] = new Player(i+1,begin,end);
        //设置特定的线程池，大小为5
        ExecutorService exe = Executors.newFixedThreadPool(PLAYER_AMOUNT);
        for(Player p:plays)
            exe.execute(p);            //分配线程
        System.out.println("Race begins!");
        begin.countDown();
        try{
            end.await();            //等待end状态变为0，即为比赛结束
        }catch (InterruptedException e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally{
            System.out.println("Race ends!");
        }
        exe.shutdown();
}
public class Player implements Runnable 
{
private int id;
private CountDownLatch begin;
private CountDownLatch end;
public Player(int i, CountDownLatch begin, CountDownLatch end) {
// TODO Auto-generated constructor stub
super();
this.id = i;
this.begin = begin;
this.end = end;
}
@Override
public void run() {
// TODO Auto-generated method stub
try{
begin.await();        //等待begin的状态为0
Thread.sleep((long)(Math.random()*100));    //随机分配时间，即运动员完成时间
System.out.println("Play"+id+" arrived.");
}catch (InterruptedException e) {
// TODO: handle exception
e.printStackTrace();
}finally{
end.countDown();    //使end状态减1，最终减至0
}
}
}
}