JavaExecutor框架学习总结

大多数并发都是通过任务执行的方式来实现的。一般有两种方式执行任务：串行和并行。

创新互联建站专注于灵寿网站建设服务及定制，我们拥有丰富的企业做网站经验。 热诚为您提供灵寿营销型网站建设，灵寿网站制作、灵寿网页设计、灵寿网站官网定制、微信小程序服务，打造灵寿网络公司原创品牌,更为您提供灵寿网站排名全网营销落地服务。

 
 
    
  
  
  1. class SingleThreadWebServer { 
    2. 
  
  
  2.   public static void main(String[] args) throws Exception { 
    3. 
  
  
  3.     ServerSocket socket = new ServerSocket(80); 
    4. 
  
  
  4.     while(true) { 
    5. 
  
  
  5.       Socket conn = socket.accept(); 
    6. 
  
  
  6.       handleRequest(conn); 
    7. 
  
  
  7.     } 
    8. 
  
  
  8.   } 
    9. 
  
  
  9. } 
    10. 
  
  
  10. class ThreadPerTaskWebServer { 
    11. 
  
  
  11.   public static void main(String[] args) throws Exception { 
    12. 
  
  
  12.     ServerSocket socket = new ServerSocket(80); 
    13. 
  
  
  13.     while(true) { 
    14. 
  
  
  14.       final Socket conn = socket.accept(); 
    15. 
  
  
  15.       Runnable task = new Runnable() { 
    16. 
  
  
  16.         public void run() { 
    17. 
  
  
  17.           handleRequest(conn); 
    18. 
  
  
  18.         } 
    19. 
  
  
  19.       }; 
    20. 
  
  
  20.       new Thread(task).start(); 
    21. 
  
  
  21.     } 
    22. 
  
  
  22.   } 
    23. 
  
  
  23. } 
    24.

当然上面的这两种方式都是有问题的。单线程的问题就是并发量会是瓶颈，多线程版本就是***制的创建线程会导致资源不足问题。

Executor 框架

任务是一组逻辑工作单元，而线程是使任务异步执行的机制。

JDK 提供了 Executor 接口：

 
 
    
  
  
  1. public interface Executor { 
    2. 
  
  
  2.     void execute(Runnable command); 
    3. 
  
  
  3. } 
    4.

虽然 Executor 接口比较简单，但是却是异步任务执行框架的基础，该框架能支持多种不同类型的任务执行策略。它提供了一种标准的方式把任务的提交过程与执行过程进行了解 耦。用 Runnable 来代表任务。Executor 的实现提供了对生命周期的支持以及统计信息应用程序管理等机制。

Executor 是基于生产者消费者模式的，提交任务的操作相当于生产者，执行任务的线程相当于消费。

基于 Executor 的 WebServer 例子如下：

 
 
    
  
  
  1. public class TaskExecutorWebServer { 
    2. 
  
  
  2.   private static final int NTHREADS = 100; 
    3. 
  
  
  3.   private static final Executor exec = Executors.newFixedThreadPool(NTHREADS); 
    4. 
  
  
  4.   public static void main(String[] args) throws Exception { 
    5. 
  
  
  5.     ServerSocket serverSocket = new ServerSocket(80); 
    6. 
  
  
  6.     while (true) { 
    7. 
  
  
  7.       final Socket conn = serverSocket.accept(); 
    8. 
  
  
  8.       Runnable task = new Runnable() { 
    9. 
  
  
  9.         @Override 
    10. 
  
  
  10.         public void run() { 
    11. 
  
  
  11.           handleRequest(conn); 
    12. 
  
  
  12.         } 
    13. 
  
  
  13.       }; 
    14. 
  
  
  14.       exec.execute(task); 
    15. 
  
  
  15.     } 
    16. 
  
  
  16.   } 
    17. 
  
  
  17. } 
    18.

另外可以自己实现 Executor 来控制是并发还是并行的，如下面代码：

 
 
    
  
  
  1. /** 
    2. 
  
  
  2. * 执行已提交的 Runnable 任务的对象。 
    3. 
  
  
  3. * 此接口提供一种将任务提交与每个任务将如何运行的机制（包括线程使用的细节、调度等）分离开来的方法。 
    4. 
  
  
  4. * 通常使用 Executor 而不是显式地创建线程。 
    5. 
  
  
  5. * 
    6. 
  
  
  6. * 
    7. 
  
  
  7. * @author renchunxiao 
    8. 
  
  
  8. * 
    9. 
  
  
  9. */ 
    10. 
  
  
  10. public class ExecutorDemo { 
    11. 
  
  
  11.   public static void main(String[] args) { 
    12. 
  
  
  12.     Executor executor = new ThreadExecutor(); 
    13. 
  
  
  13.     executor.execute(new Runnable() { 
    14. 
  
  
  14.       @Override 
    15. 
  
  
  15.       public void run() { 
    16. 
  
  
  16.         // do something 
    17. 
  
  
  17.       } 
    18. 
  
  
  18.     }); 
    19. 
  
  
  19.     Executor executor2 = new SerialExecutor(); 
    20. 
  
  
  20.     executor2.execute(new Runnable() { 
    21. 
  
  
  21.       @Override 
    22. 
  
  
  22.       public void run() { 
    23. 
  
  
  23.         // do something 
    24. 
  
  
  24.       } 
    25. 
  
  
  25.     }); 
    26. 
  
  
  26.   } 
    27. 
  
  
  27. } 
    28. 
  
  
  28. /** 
    29. 
  
  
  29. * 创建一个线程来执行 command 
    30. 
  
  
  30. * 
    31. 
  
  
  31. * @author renchunxiao 
    32. 
  
  
  32. * 
    33. 
  
  
  33. */ 
    34. 
  
  
  34. class ThreadExecutor implements Executor { 
    35. 
  
  
  35.   @Override 
    36. 
  
  
  36.   public void execute(Runnable command) { 
    37. 
  
  
  37.     new Thread(command).start(); 
    38. 
  
  
  38.   } 
    39. 
  
  
  39. } 
    40. 
  
  
  40. /** 
    41. 
  
  
  41. * 串行执行 command 
    42. 
  
  
  42. * 
    43. 
  
  
  43. * @author renchunxiao 
    44. 
  
  
  44. * 
    45. 
  
  
  45. */ 
    46. 
  
  
  46. class SerialExecutor implements Executor { 
    47. 
  
  
  47.   @Override 
    48. 
  
  
  48.   public void execute(Runnable command) { 
    49. 
  
  
  49.     command.run(); 
    50. 
  
  
  50.   } 
    51. 
  
  
  51. } 
    52.

线程池

线程池就是线程的资源池，可以通过 Executors 中的静态工厂方法来创建线程池。

  • newFixedThreadPool。创建固定长度的线程池，每次提交任务创建一个线程，直到达到线程池的***数量，线程池的大小不再变化。

  • newSingleThreadExecutor。单个线程池。

  • newCachedThreadPool。根据任务规模变动的线程池。

  • newScheduledThreadPool。创建固定长度的线程池，以延迟或定时的方式来执行任务。

JVM 只有在所有非守护线程全部终止后才会退出，所以，如果无法正确的关闭 Executor，那么 JVM 就无法结束。

为了解决执行服务的生命周期问题，有个扩展 Executor 接口的新接口 ExecutorService。

 
 
    
  
  
  1. public interface ExecutorService extends Executor { 
    2. 
  
  
  2.   void shutdown(); 
    3. 
  
  
  3.   List shutdownNow(); 
    4. 
  
  
  4.   boolean isShutdown(); 
    5. 
  
  
  5.   boolean isTerminated(); 
    6. 
  
  
  6.   boolean awaitTermination(long timeout, TimeUnit unit) 
    7. 
  
  
  7.     throws InterruptedException; 
    8. 
  
  
  8.    Future submit(Callable task); 
    9. 
  
  
  9.    Future submit(Runnable task, T result); 
    10. 
  
  
  10.   Future submit(Runnable task); 
    11. 
  
  
  11.    List> invokeAll(Collection> tasks) 
    12. 
  
  
  12.     throws InterruptedException; 
    13. 
  
  
  13.    List> invokeAll(Collection> tasks, 
    14. 
  
  
  14.                   long timeout, TimeUnit unit) 
    15. 
  
  
  15.     throws InterruptedException; 
    16. 
  
  
  16.    T invokeAny(Collection> tasks) 
    17. 
  
  
  17.     throws InterruptedException, ExecutionException; 
    18. 
  
  
  18.    T invokeAny(Collection> tasks, 
    19. 
  
  
  19.           long timeout, TimeUnit unit) 
    20. 
  
  
  20.     throws InterruptedException, ExecutionException, TimeoutException; 
    21. 
  
  
  21. } 
    22.

ExecutorService 生命周期有三种状态：运行、关闭、已终止。ExecutorService 在初始创建时处于运行状态。shutdown 方法会平缓关闭：不在接受新的任务，并且等待已经执行的任务执行完成(包括那些还未开始的任务)。shutdownNow 方法将粗暴关闭：它将尝试取消所有运行中的任务，并且不再启动队列中尚未开始的任务。所有任务都执行完成后进入到已终止状态。

Callable 和 Future

Executor 框架使用 Runnable 作为基本的任务表示形式。Runnable 是一种有局限性的抽象，它的 run 方法不能返回值和抛出一个受检查异常。

许多任务实际上是存在延时的计算，例如数据库查询，从网络获取资源。对于这些任务，Callable 是更好的抽象，它认为 call 将返回一个值，并且可能抛出异常。

Executor 执行的任务有四个生命周期阶段:创建、提交、开始和完成。由于有些任务需要很长时间有可能希望取消，在 Executor 框架当中，已提交未开始的任务可以取消。

Future 表示一个任务的生命周期，并且提供了相应的方法来判断是否已经完成或取消，以及获取任务的结果和取消任务等。

网站标题：JavaExecutor框架学习总结
地址分享：http://www.mswzjz.cn/qtweb/news18/15818.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

网站策划知识

分类信息网站

班戈纳美网站　　 　网站推广优化　　 　成都网站设计　　 　成都西信机房　　 　成都400电话　　 　Google外贸推广　　 　成都网站设计　　 　四川盐亭做网站　　 　微博营销　　 　小谭建站工作室　　 　四川航空文化　　 　IDC机房托管　　 　成都柴油发电机组　　 　鸿艺文化　　 　名片印刷　　 　成都网站设计　　 　成都工装公司　　 　成都网站优化　　 　成都公司注册代办　　 　上市企业网站建设方案