|
|
51CTO旗下网站
|
|
移动端

Android自定义线程池的编程实战

Executor框架便是Java 5中引入的,其内部使用了线程池机制,它在java.util.cocurrent 包下,通过该框架来控制线程的启动、执行和关闭,可以简化并发编程的操作。

作者:赵彦军来源:博客园|2016-08-18 13:56

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); 

2、ExecutorService

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

  1. public interface ExecutorService extends Executor { 
  2.  
  • 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. executorService.shutdown(); 
  31.  
  32.  

结果:

  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. try { 
  31.  
  32. //如果任务结束执行则返回 null 
  33.  
  34. Log.d( ""+ future.get() ); 
  35.  
  36. } catch (Exception e) { 
  37.  
  38. e.printStackTrace(); 
  39.  
  40.  
  41. //关闭线程池 
  42.  
  43. executorService.shutdown(); 
  44.  
  45.  

结果:

  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. try { 
  33.  
  34. //如果任务结束执行则返回 
  35.  
  36. Log.d( "结果是: "+ future.get() ); 
  37.  
  38. } catch (Exception e) { 
  39.  
  40. e.printStackTrace(); 
  41.  
  42.  
  43. //关闭线程池 
  44.  
  45. executorService.shutdown(); 
  46.  
  47.  

结果:

结果是: 执行完了

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. //创建第二个 Callable 
  41.  
  42. Callable<String> callable2 = new Callable<String>() { 
  43.  
  44. @Override 
  45.  
  46. public String call() throws Exception { 
  47.  
  48. Log.d( "callable 2 线程是: "+ Thread.currentThread().getName() ); 
  49.  
  50. return "执行完了 callable 2" ; 
  51.  
  52.  
  53. }; 
  54.  
  55. list.add( callable1 ) ; 
  56.  
  57. list.add( callable2 ) ; 
  58.  
  59. try { 
  60.  
  61. String result = executorService.invokeAny( list ) ; 
  62.  
  63. Log.d( "结果是: "+ result ); 
  64.  
  65. } catch (InterruptedException e1) { 
  66.  
  67. e1.printStackTrace(); 
  68.  
  69. } catch (ExecutionException e1) { 
  70.  
  71. e1.printStackTrace(); 
  72.  
  73.  
  74. //关闭线程池 
  75.  
  76. executorService.shutdown(); 
  77.  
  78.  

结果:

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. //创建第二个 Callable 
  41.  
  42. Callable<String> callable2 = new Callable<String>() { 
  43.  
  44. @Override 
  45.  
  46. public String call() throws Exception { 
  47.  
  48. Log.d( "callable 2 线程是: "+ Thread.currentThread().getName() ); 
  49.  
  50. return "执行完了 callable 2" ; 
  51.  
  52.  
  53. }; 
  54.  
  55. list.add( callable1 ) ; 
  56.  
  57. list.add( callable2 ) ; 
  58.  
  59. List<Future<String>> result; 
  60.  
  61. try { 
  62.  
  63. result = executorService.invokeAll( list ); 
  64.  
  65. for (Future<String> future : result) { 
  66.  
  67. Log.d( "结果是: "+ future.get() ); 
  68.  
  69.  
  70. } catch (Exception e) { 
  71.  
  72. e.printStackTrace(); 
  73.  
  74.  
  75. //关闭线程池 
  76.  
  77. executorService.shutdown(); 
  78.  
  79.  

结果

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() 方法。这个方法会尝试马上关闭所有正在执行的任务,并且跳过所有已经提交但是还没有运行的任务。但是对于正在执行的任务,是否能够成功关闭它是无法保证 的,有可能他们真的被关闭掉了,也有可能它会一直执行到任务结束。这是一个***的尝试。

【编辑推荐】

  1. 使用钩子技术改进Android程序安全性
  2. 基于Android TTS服务开发智能助手
  3. 使用Xamarin和Visual Studio开发Android可穿戴设备应用
  4. Android 7.0正式版8月登场 无缘Nexus 5
  5. Android与iOS谁更优秀?消费者必看的五大对决
【责任编辑:武晓燕 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

订阅专栏+更多

16招轻松掌握PPT技巧

16招轻松掌握PPT技巧

GET职场加薪技能
共16章 | 晒书包

289人订阅学习

20个局域网建设改造案例

20个局域网建设改造案例

网络搭建技巧
共20章 | 捷哥CCIE

645人订阅学习

WOT2019全球人工智能技术峰会

WOT2019全球人工智能技术峰会

通用技术、应用领域、企业赋能三大章节,13大技术专场,60+国内外一线人工智能精英大咖站台,分享人工智能的平台工具、算法模型、语音视觉等技术主题,助力人工智能落地。
共50章 | WOT峰会

0人订阅学习

读 书 +更多

Visual C# 2005技术内幕

本书提供了.NET框架下C#编程的详尽指南。书中详细介绍了.NET框架中的核心概念、使用GDI+编写高级用户界面、多线程程序设计、使用ClickOnc...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO播客