1、Executor 简介

在Java 5之后，并发编程引入了一堆新的启动、调度和管理线程的API。Executor框架便是Java 5中引入的，其内部使用了线程池机制，它在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作。因此，在Java 5之后，通过Executor来启动线程比使用Thread的start方法更好，除了更易管理，效率更好(用线程池实现，节约开销)外，还有关键的一点：有助于避免this逃逸问题——如果我们在构造器中启动一个线程，因为另一个任务可能会在构造器结束之前开始执行，此时可能会访问到初始化了一半的对象用Executor在构造器中。

Executor框架包括：线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。

在java代码中 Executor是一个接口，只有一个方法。

1. public interface Executor { 
2.   
3.     /** 
4.      * Executes the given command at some time in the future.  The command 
5.      * may execute in a new thread, in a pooled thread, or in the calling 
6.      * thread, at the discretion of the {@code Executor} implementation. 
7.      * 
8.      * @param command the runnable task 
9.      * @throws RejectedExecutionException if this task cannot be 
10.      * accepted for execution 
11.      * @throws NullPointerException if command is null 
12.      */ 
13.     void execute(Runnable command); 
14. } 

2、ExecutorService

ExecutorService 是一个接口，继承 Executor ，除了有execute( Runnable command) 方法外，还拓展其他的方法：

1. public interface ExecutorService extends Executor { 
2.  
3. } 

• void shutdown();
• List<Runnable> shutdownNow();
• boolean isShutdown();
• boolean isTerminated();
• boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
• <T> Future<T> submit(Callable<T> task); //提交一个任务
• <T> Future<T> submit(Runnable task, T result); //提交一个任务
• Future<?> submit(Runnable task); //提交一个任务
• <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;
• <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;
• <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
• <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;

2.1 execute(Runnable)

接收一个 java.lang.Runnable 对象作为参数，并且以异步的方式执行它。如下是一个使用 ExecutorService 执行 Runnable 的例子

1. package com.app; 
2.  
3. import java.util.concurrent.ExecutorService; 
4.  
5. import java.util.concurrent.Executors; 
6.  
7. public class ExecutorTest { 
8.  
9. public static void main(String[] args) { 
10.  
11. //创建一个线程数固定大小为10的线程池 
12.  
13. ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ; 
14.  
15. //执行一个任务 该任务是 new Runnable() 对象 
16.  
17. executorService.execute( new Runnable() { 
18.  
19. @Override 
20.  
21. public void run() { 
22.  
23. Log.d( Thread.currentThread().getName() ); 
24.  
25. } 
26.  
27. }); 
28.  
29. //关闭线程池 
30.  
31. executorService.shutdown(); 
32.  
33. } 
34.  
35. } 

结果：

1. pool-1-thread-1 

使用这种方式没有办法获取执行 Runnable 之后的结果，如果你希望获取运行之后的返回值，就必须使用 接收 Callable 参数的 execute() 方法，后者将会在下文中提到。

2.2、submit(Runnable)

方法 submit(Runnable) 同样接收一个 Runnable 的实现作为参数，但是会返回一个 Future 对象。这个 Future 对象可以用于判断 Runnable 是否结束执行。如下是一个 ExecutorService 的 submit() 方法的例子：

1. package com.app; 
2.  
3. import java.util.concurrent.ExecutorService; 
4.  
5. import java.util.concurrent.Executors; 
6.  
7. import java.util.concurrent.Future; 
8.  
9. public class ExecutorTest { 
10.  
11. public static void main(String[] args) { 
12.  
13. //创建一个线程数固定大小为10的线程池 
14.  
15. ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ; 
16.  
17. //执行一个任务 该任务是 new Runnable() 对象 
18.  
19. Future future = executorService.submit( new Runnable() { 
20.  
21. @Override 
22.  
23. public void run() { 
24.  
25. Log.d( Thread.currentThread().getName() ); 
26.  
27. } 
28.  
29. }); 
30.  
31. try { 
32.  
33. //如果任务结束执行则返回 null 
34.  
35. Log.d( ""+ future.get() ); 
36.  
37. } catch (Exception e) { 
38.  
39. e.printStackTrace(); 
40.  
41. } 
42.  
43. //关闭线程池 
44.  
45. executorService.shutdown(); 
46.  
47. } 
48.  
49. } 

结果：

1. pool-1-thread-1 
2.  
3. null 

2.3 submit(Callable)

方法 submit(Callable) 和方法 submit(Runnable) 比较类似，但是区别则在于它们接收不同的参数类型。Callable 的实例与 Runnable 的实例很类似，但是 Callable 的 call() 方法可以返回壹個结果。方法 Runnable.run() 则不能返回结果。

Callable 的返回值可以从方法 submit(Callable) 返回的 Future 对象中获取。如下是一个 ExecutorService Callable 的例子：

1. package com.app; 
2.  
3. import java.util.concurrent.Callable; 
4.  
5. import java.util.concurrent.ExecutorService; 
6.  
7. import java.util.concurrent.Executors; 
8.  
9. import java.util.concurrent.Future; 
10.  
11. public class ExecutorTest { 
12.  
13. public static void main(String[] args) { 
14.  
15. //创建一个线程数固定大小为10的线程池 
16.  
17. ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ; 
18.  
19. //执行一个任务 该任务是 new Callable() 对象 
20.  
21. Future future = executorService.submit( new Callable<String>() { 
22.  
23. @Override 
24.  
25. public String call() throws Exception { 
26.  
27. return "执行完了" ; 
28.  
29. } 
30.  
31. }) ; 
32.  
33. try { 
34.  
35. //如果任务结束执行则返回 
36.  
37. Log.d( "结果是： "+ future.get() ); 
38.  
39. } catch (Exception e) { 
40.  
41. e.printStackTrace(); 
42.  
43. } 
44.  
45. //关闭线程池 
46.  
47. executorService.shutdown(); 
48.  
49. } 
50.  
51. } 

结果：

结果是： 执行完了

2.4、inVokeAny()

方法 invokeAny() 接收一个包含 Callable 对象的集合作为参数。调用该方法不会返回 Future 对象，而是返回集合中某一个 Callable 对象的结果，而且无法保证调用之后返回的结果是哪一个 Callable，只知道它是这些 Callable 中一个执行结束的 Callable 对象。如果一个任务运行完毕或者抛出异常，方法会取消其它的 Callable 的执行。

1. package com.app; 
2.  
3. import java.util.ArrayList; 
4.  
5. import java.util.List; 
6.  
7. import java.util.concurrent.Callable; 
8.  
9. import java.util.concurrent.ExecutionException; 
10.  
11. import java.util.concurrent.ExecutorService; 
12.  
13. import java.util.concurrent.Executors; 
14.  
15. public class ExecutorTest { 
16.  
17. public static void main(String[] args) { 
18.  
19. //创建一个线程数固定大小为10的线程池 
20.  
21. ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ; 
22.  
23. List<Callable<String>> list = new ArrayList<>() ; 
24.  
25. //创建第一个 Callable 
26.  
27. Callable<String> callable1 = new Callable<String>() { 
28.  
29. @Override 
30.  
31. public String call() throws Exception { 
32.  
33. Log.d( "callable 1 线程是： "+ Thread.currentThread().getName() ); 
34.  
35. return "执行完了 callable 1" ; 
36.  
37. } 
38.  
39. }; 
40.  
41. //创建第二个 Callable 
42.  
43. Callable<String> callable2 = new Callable<String>() { 
44.  
45. @Override 
46.  
47. public String call() throws Exception { 
48.  
49. Log.d( "callable 2 线程是： "+ Thread.currentThread().getName() ); 
50.  
51. return "执行完了 callable 2" ; 
52.  
53. } 
54.  
55. }; 
56.  
57. list.add( callable1 ) ; 
58.  
59. list.add( callable2 ) ; 
60.  
61. try { 
62.  
63. String result = executorService.invokeAny( list ) ; 
64.  
65. Log.d( "结果是： "+ result ); 
66.  
67. } catch (InterruptedException e1) { 
68.  
69. e1.printStackTrace(); 
70.  
71. } catch (ExecutionException e1) { 
72.  
73. e1.printStackTrace(); 
74.  
75. } 
76.  
77. //关闭线程池 
78.  
79. executorService.shutdown(); 
80.  
81. } 
82.  
83. } 

结果：

callable 1 线程是： pool-1-thread-1

callable 2 线程是： pool-1-thread-2

结果是： 执行完了 callable 2

总结：

1、可以看到 Callable 里面的call方法，都是在子线程中运行的，

2、 executorService.invokeAny( list ) ;返回值是任意一个 Callable 的返回值 。具体是哪一个，每个都有可能。

2.5、invokeAll()

方法 invokeAll() 会调用存在于参数集合中的所有 Callable 对象，并且返回一个包含 Future 对象的集合，你可以通过这个返回的集合来管理每个 Callable 的执行结果。需要注意的是，任务有可能因为异常而导致运行结束，所以它可能并不是真的成功运行了。但是我们没有办法通过 Future 对象来了解到这个差异。

1. package com.app; 
2.  
3. import java.util.ArrayList; 
4.  
5. import java.util.List; 
6.  
7. import java.util.concurrent.Callable; 
8.  
9. import java.util.concurrent.ExecutorService; 
10.  
11. import java.util.concurrent.Executors; 
12.  
13. import java.util.concurrent.Future; 
14.  
15. public class ExecutorTest { 
16.  
17. public static void main(String[] args) { 
18.  
19. //创建一个线程数固定大小为10的线程池 
20.  
21. ExecutorService executorService = Executors.newFixedThreadPool( 10 ) ; 
22.  
23. List<Callable<String>> list = new ArrayList<>() ; 
24.  
25. //创建第一个 Callable 
26.  
27. Callable<String> callable1 = new Callable<String>() { 
28.  
29. @Override 
30.  
31. public String call() throws Exception { 
32.  
33. Log.d( "callable 1 线程是： "+ Thread.currentThread().getName() ); 
34.  
35. return "执行完了 callable 1" ; 
36.  
37. } 
38.  
39. }; 
40.  
41. //创建第二个 Callable 
42.  
43. Callable<String> callable2 = new Callable<String>() { 
44.  
45. @Override 
46.  
47. public String call() throws Exception { 
48.  
49. Log.d( "callable 2 线程是： "+ Thread.currentThread().getName() ); 
50.  
51. return "执行完了 callable 2" ; 
52.  
53. } 
54.  
55. }; 
56.  
57. list.add( callable1 ) ; 
58.  
59. list.add( callable2 ) ; 
60.  
61. List<Future<String>> result; 
62.  
63. try { 
64.  
65. result = executorService.invokeAll( list ); 
66.  
67. for (Future<String> future : result) { 
68.  
69. Log.d( "结果是： "+ future.get() ); 
70.  
71. } 
72.  
73. } catch (Exception e) { 
74.  
75. e.printStackTrace(); 
76.  
77. } 
78.  
79. //关闭线程池 
80.  
81. executorService.shutdown(); 
82.  
83. } 
84.  
85. } 

结果

callable 1 线程是： pool-1-thread-1

callable 2 线程是： pool-1-thread-2

结果是： 执行完了 callable 1

结果是： 执行完了 callable 2

注意：1：Callable 的call方法都是执行在子线程中的

2： executorService.invokeAll( list ) 是返回值。 但是必须是所有的 Callable对象执行完了，才会返回，返回值是一个list, 顺序和 List<Callable>一样 。在执行的过程中，如果任何一个Callable发生异常，程序会崩溃，没有返回值。

2.6 如何关闭 ExecuteService 服务 ?

当使用 ExecutorService 完毕之后，我们应该关闭它，这样才能保证线程不会继续保持运行状态。 举例来说，如果你的程序通过 main() 方法启动，并且主线程退出了你的程序，如果你还有一个活动的 ExecutorService 存在于你的程序中，那么程序将会继续保持运行状态。存在于 ExecutorService 中的活动线程会阻Java虚拟机关闭。

为了关闭在 ExecutorService 中的线程，你需要调用 shutdown() 方法。ExecutorService 并不会马上关闭，而是不再接收新的任务，一旦所有的线程结束执行当前任务，ExecutorServie 才会真的关闭。所有在调用 shutdown() 方法之前提交到 ExecutorService 的任务都会执行。

如果你希望立即关闭 ExecutorService，你可以调用 shutdownNow() 方法。这个方法会尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务。但是对于正在执行的任务，是否能够成功关闭它是无法保证 的，有可能他们真的被关闭掉了，也有可能它会一直执行到任务结束。这是一个最好的尝试。

作者：赵彦军

来源：51CTO