Java并发包：ExecutorService和ThreadPoolExecutor

文章译自：http://tutorials.jenkov.com/java-util-concurrent/index.html
抽空翻译了一下这个教程的文章，后面会陆续放出，如有不妥，请批评指正。
转自请注明出处。

ExecutorService

Java.util.concurrent.ExecutorService接口代表一种异步执行机制，它能够在后台执行任务。因此ExecutorService与thread pool是非常相似的。事实上，在java.util.package包中ExecutorService的具体实现就是一个线程池的具体实现。

ExcutorService 例子

下面是一个简单的例子

ExecutorService executorService = Executors.newFixedThreadPool(10);executorService.execute(new Runnable() {public void run() {System.out.println("Asynchronous task");}
});executorService.shutdown();

首先，通过newFixedThreadPool()工厂方法创建一个ExecutorService的实例。这个方法创建了一个可以有10个线程执行任务的线程池。

第二，Runnable接口的匿名实现类作为参数被传递给execute()方法。Runable将会被ExecutorService中的一个线程来执行。

任务委托（Task Delegation）

下面的图片说明了一个线程委托一个任务给ExecutorService进行异步执行：

一旦，线程委托任务给ExecutorService，线程会独立任务的执行而继续自己之后的操作。

ExcutorService的使用说明

下面是委托任务给ExecutorService的一些不同的方式：

execute(Runnable)
submit(Runnable)
submit(Callable)
invokeAny(…)
invokeAll(…)

下面来逐个看看这些方法。

execute(Runnable)

execute(Runnable) 方法接受一个java.lang.Runable对象的实例，并异步执行之。下面是一个使用ExecutorService执行Runnable的例子：

ExecutorService executorService = Executors.newSingleThreadExecutor();executorService.execute(new Runnable() {public void run() {System.out.println("Asynchronous task");}
});executorService.shutdown();

这种方式不能获得Runnable执行的结果，如果有这种需要，你将要使用Callable。

submit(Runnable)

submit(Runnable) 方法也接收一个Runnable接口的具体实现，并返回一个Future对象。Future对象可以用来检测Runable是否执行完成。

Future future = executorService.submit(new Runnable() {public void run() {System.out.println("Asynchronous task");}
});future.get();  //returns null if the task has finished correctly.

submit(Callable)

submit(Callable)方法与submit(Runnable)方法相似，除了接收的参数有所不同。Callable实例非常类似于Runnable,不同的是call方法可以返回一个结果，Runnable.run()方法不能返回一个结果。

可以通过submit(Callable)方法返回的Future对象获取Callable的结果。下面是一个使用Callable的例子：

Future future = executorService.submit(new Callable(){public Object call() throws Exception {System.out.println("Asynchronous Callable");return "Callable Result";}
});System.out.println("future.get() = " + future.get());

上面代码的输出结果是：

Asynchronous Callable
future.get() = Callable Result

invokeAny(…)

invokeAny()方法接收一个Callable对象或者Callable的子接口实例的集合作为参数，这个方法不会返回Future,但会返回集合中某一个Callable的结果。你不能确定你得到是哪个Callable的结果。只是已执行完成的Callable中的一个。

如果一个任务已经完成（或者抛出了异常），剩余的Callable任务将被取消。
下面是示例代码：

ExecutorService executorService = Executors.newSingleThreadExecutor();Set<Callable<String>> callables = new HashSet<Callable<String>>();callables.add(new Callable<String>() {public String call() throws Exception {return "Task 1";}
});
callables.add(new Callable<String>() {public String call() throws Exception {return "Task 2";}
});
callables.add(new Callable<String>() {public String call() throws Exception {return "Task 3";}
});String result = executorService.invokeAny(callables);System.out.println("result = " + result);executorService.shutdown();

示例代码将会打印给定的Callable集合中一个Callable任务返回的结果。我尝试执行了多次，结果是变化的。有时候是“Task1”,有时候是“Task 2”等。

invokeAll(…)

invokeAll()接收一个Callable对象的集合作为参数，该方法会调用你传给他的集合中的所有Callable对象。invokeAll()会返回一个Future对象的列表，通过这个列表你可以获取每一个Callable执行的结果。

记住一个任务可能会因为一个异常而结束，因此这时任务并不是真正意义上执行成功了。这在Future上是没有办法来判断的。

下面是示例代码：

ExecutorService executorService = Executors.newSingleThreadExecutor();Set<Callable<String>> callables = new HashSet<Callable<String>>();callables.add(new Callable<String>() {public String call() throws Exception {return "Task 1";}
});
callables.add(new Callable<String>() {public String call() throws Exception {return "Task 2";}
});
callables.add(new Callable<String>() {public String call() throws Exception {return "Task 3";}
});List<Future<String>> futures = executorService.invokeAll(callables);for(Future<String> future : futures){System.out.println("future.get = " + future.get());
}executorService.shutdown();

ExecutorService Shutdown

当你是使用完ExecutorService后，你应该关闭它，使得线程不能持续运行。例如，你的应用程序从main()方法开始并且你的主线程退出应用程序，这时如果存在激活状态的ExecutorService，你的应用程序将仍然会保持运行。ExecutorService中激活的线程会阻止JVM关闭。

为了终止ExecutorService中的线程，你需要调用shutdown()方法。ExecutorService不会立即关闭，但是它也不会接受新的任务，直到它里面的所有线程都执行完毕，ExecutorService才会关闭。所有提交到ExecutorService中的任务会在调用shutdown()方法之前被执行。

如果你想立即关闭ExecutorService,你可以调用shutdownNow()方法。这将会尝试立即停止所有正在执行的任务，并且忽略所有提交的但未被处理的任务。对于正在执行的任务是不能确定的，也许它们停止了，也行它们执行直到结束。

ThreadPoolExecutor

Java.util.concurrent.ThreadPoolExecutor类是ExecutorSerivce接口的具体实现。ThreadPoolExecutor使用线程池中的一个线程来执行给定的任务（Runnable或者Runnable）。

ThreadPoolExecutor内部的线程池包含不定数量的线程。池中线程的数量由下面的这些变量决定：

corePoolSize
maximumPoolSize

当一个任务委托给线程池执行，此时如果池线程中线程数少于corePoolSize，即使池中有空闲的线程，线程池中也会创建一个新的线程。

如果任务队列是满的，corePoolSize个线程或者更多的且少于maximumPoolSize的线程正在运行，也会创建一个新的线程来执行任务。

下面图释ThreadPoolExecutor这种原理：

创建ThreadPoolExecutor

ThreadPoolExecutor有多种构造函数。例如：

int  corePoolSize  =    5;
int  maxPoolSize   =   10;
long keepAliveTime = 5000;ExecutorService threadPoolExecutor =new ThreadPoolExecutor(corePoolSize,maxPoolSize,keepAliveTime,TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());

除非你需要显示的给ThreadPoolExecutor指定这些参数，通常使用java.util.concurrent.Executor类中的工厂方法来创建实例。