Java 并发 – 第七部分：Executors 与线程池（转）

现在让我们开始 Java 并发系列的新篇章。这壹次我们会学习如何干净的启动壹個新线程，以及如何在线程池中管理它。在 Java 中，假设你有壹個像下面这样的 Runnable 线程：

1
Runnable runnable = new Runnable(){

2
   public void run(){

3
      System.out.println("Run");

4
   }

5
}

你可以简单的在壹個线程中运行它：

1
new Thread(runnable).start();

这個代码很简洁，但是如果我们想并行的启动多個任务该怎么办呢，而且我们还想等待所有任务完成之后获取所有任务的返回值，这样的话，要想保持较好的代码风格实际上有点困难了。不过，就像所有其它的难题壹样，Java 为我们提供了壹個解决方案，那就是 Executor ，这個简单的类允许你创建线程池和线程工厂。

1
ExecutorService executor = Executors.newFixedThreadPool(5);

2
for (int i = 0; i < 10; i++) {

3
    executor.execute(new Runnable() {

4
        public void run() {

5
            System.out.println("do something here...");

6
        }

7
    });

8
  }

9
executor.shutdown();

线程池实际表现为 ExecutorService 类的壹個实例。通过使用 ExecutorService ，你可以提交将在未来完成的任务。通过 Executor 类你可以创建如下几种线程池：

1、Single Thread Executor：只有壹個线程的线程池。所以所有提交的任务都会被顺序执行。方法名称：Executors.newSingleThreadExecutor()；
2、Cache Thread Pool：壹個创建足够多的线程的线程池，可以并行的执行所有任务。旧的线程会被重新用于新的任务。如果线程在60秒内没有被用到，这個线程就会被终止并且从线程池中移除掉。方法名称：Executors.newCachedThreadPool()；
3、Fixed Thread Pool：壹個有着固定数量的线程的线程池。如果对于某個任务而言某线程不可用，这個任务会被放进队列中等待其它的任务完成之后再执行。方法名称：Executors.newFixedThreadPool()；
4、Scheduled Thread Pool：壹個为定时任务准备的线程池。方法名称：Executors.newScheduledThreadPool()；
5、Single Thread Scheduled Pool：壹個为定时的未来的任务准备的单個线程的线程池，方法名称：Executors.newSingleThreadScheduledExecutor()；

壹旦你有了壹個线程池，你可以使用上述不同的提交方法提交你的任务了。你可以提交壹個 Runnable 或者 Callable 的任务到线程池中。这個方法返回壹個 Future 对象，用于表示这個任务在未来的状态。如果你提交壹個 Runnable 的任务，那么壹旦任务结束， Future 将返回 null 。
举個例子，如果你有如下这样壹個 Callable 的任务：

1
private final class StringTask implements Callable<String> {

2
   public String call(){

3
      //耗时的操作

4
      return "Run";

5
   }

6
}

如果你希望使用4個线程执行该任务10次，你可以使用如下代码：

1
ExecutorService pool = Executors.newFixedThreadPool(4);

2
 
3
for(int i = 0; i < 10; i++){

4
   pool.submit(new StringTask());

5
}

但是你必须关闭线程池才能结束池中的所有线程：

1
pool.shutdown();

如果你不这样做，Java 虚拟机就存在不能关闭的风险，因为仍然有线程没有终止。现在你可以使用 shutdown() 方法强制关闭线程池，但是这样壹来当前正在执行的任务将会被中断，而没有启动的线程永远都不会再启动了。
然而，如果使用上面的样例代码，你永远不会获得任务执行后的结果。所以我们接下来使用 Future 对象来完成这些任务：

01
ExecutorService pool = Executors.newFixedThreadPool(4);

02
List<Future<String>> futures = new ArrayList<Future<String>>(10);

03
for(int i = 0; i < 10; i++){

04
   futures.add(pool.submit(new StringTask()));

05
}

06
 
07
for(Future<String> future : futures){

08
   String result = future.get();

09
   //计算结果

10
}

11
 
12
pool.shutdown();

但是使用这种代码略有点复杂，而且有個缺点。如果第壹個任务花了很长时间去计算，而其它任务在它之前先结束了，当前线程在第壹個线程结果之前就不能计算结果。再壹次，Java 为我们提供了壹個解决方案，这就是 CompletionService 。
CompletionService 是壹個服务，它可以让 executor 等待提交任务的执行结果变得容易。它的壹個实现 ExecutorCompletionService 是基于 ExecutorService 来完成工作的。所以让我们来试试：

01
ExecutorService threadPool = Executors.newFixedThreadPool(4);

02
CompletionService<String> pool = new ExecutorCompletionService<String>(threadPool);

03
 
04
for(int i = 0; i < 10; i++){

05
   pool.submit(new StringTask());

06
}

07
 
08
for(int i = 0; i < 10; i++){

09
   String result = pool.take().get();

10
   //计算结果

11
}

12
 
13
threadPool.shutdown();

通过这种方式，你可以按照它们完成任务的顺序获得结果而不必持有壹個所有 Future 对象的集合。
通过上述介绍，你的手里现在有了使用线程池来处理并行任务的高性能工具，通过使用 Executors，ExecutorService 和 CompletionService 你可以创建壹個复杂的算法来使用多個任务。通过使用这些工具，改变并行运行的线程数量，或者增加更多任务而不改变很多代码也变的容易了。我希望这篇文章能够帮助你写出更好的并行运算的代码。

本文英文原文出自 http://www.baptiste-wicht.com/2010/09/java-concurrency-part-7-executors-and-thread-pools/，中文翻译首发开源中国社区http://my.oschina.net/bairrfhoinn/blog/167113，转载请注明原始出处。

2013-10-21 09:54:00 更新：刚刚发现这篇文章的翻译文章，红薯已经在之前的讨论版块发过了，链接见于 http://www.oschina.net/question/12_11255 ，貌似我重复造轮子了，汗壹個！