`
wsmajunfeng
  • 浏览: 496875 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

(转)java并发编程-Executor框架

 
阅读更多

Executor框架是指java 5中引入的一系列并发库中与executor相关的一些功能类,其中包括线程 池,Executor,Executors,ExecutorService,CompletionService,Future,Callable等。 他们的关系为:


 

并发编程的一种编程方式是把任务拆分为一些列的小任务,即Runnable,然后在提交给一个Executor执行,Executor.execute(Runnalbe) 。Executor在执行时使用内部的线程池完成操作。

一、创建线程池

Executors类,提供了一系列工厂方法用于创先线程池,返回的线程池都实现了ExecutorService接口。

public static ExecutorService newFixedThreadPool(int nThreads)

创建固定数目线程的线程池。

public static ExecutorService newCachedThreadPool()

创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

public static ExecutorService newSingleThreadExecutor()

创建一个单线程化的Executor。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。

Java代码  收藏代码
  1. Executor executor = Executors.newFixedThreadPool( 10 );  
  2. Runnable task = new  Runnable() {  
  3.     @Override   
  4.     public   void  run() {  
  5.         System.out.println("task over" );  
  6.     }  
  7. };  
  8. executor.execute(task);  
  9.   
  10. executor = Executors.newScheduledThreadPool(10 );  
  11. ScheduledExecutorService scheduler = (ScheduledExecutorService) executor;  
  12. scheduler.scheduleAtFixedRate(task, 10 10 , TimeUnit.SECONDS);  

 二、ExecutorService与生命周期

ExecutorService扩展了Executor并添加了一些生命周期管理的方法。一个Executor的生命周期有三种状态,运行关闭终止 。Executor创建时处于运行状态。当调用ExecutorService.shutdown()后,处于关闭状态,isShutdown()方法返 回true。这时,不应该再想Executor中添加任务,所有已添加的任务执行完毕后,Executor处于终止状态,isTerminated()返 回true。

如果Executor处于关闭状态,往Executor提交任务会抛出unchecked exception RejectedExecutionException。

Java代码  收藏代码
  1. ExecutorService executorService = (ExecutorService) executor;  
  2. while  (!executorService.isShutdown()) {  
  3.     try  {  
  4.         executorService.execute(task);  
  5.     } catch  (RejectedExecutionException ignored) {  
  6.           
  7.     }  
  8. }  
  9. executorService.shutdown();  

 三、使用Callable,Future返回结果

Future<V>代表一个异步执行的操作,通过get()方法可以获得操作的结果,如果异步操作还没有完成,则,get()会使当前 线程阻塞。FutureTask<V>实现了Future<V>和Runable<V>。Callable代表一个 有返回值得操作。

Java代码  收藏代码
  1. Callable<Integer> func =  new  Callable<Integer>(){  
  2.     public  Integer call()  throws  Exception {  
  3.         System.out.println("inside callable" );  
  4.         Thread.sleep(1000 );  
  5.         return   new  Integer( 8 );  
  6.     }         
  7. };        
  8. FutureTask<Integer> futureTask  = new  FutureTask<Integer>(func);  
  9. Thread newThread = new  Thread(futureTask);  
  10. newThread.start();  
  11.   
  12. try  {  
  13.     System.out.println("blocking here" );  
  14.     Integer result = futureTask.get();  
  15.     System.out.println(result);  
  16. catch  (InterruptedException ignored) {  
  17. catch  (ExecutionException ignored) {  
  18. }  

 ExecutoreService提供了submit()方法,传递一个Callable,或Runnable,返回Future。如果Executor后台线程池还没有完成Callable的计算,这调用返回Future对象的get()方法,会阻塞直到计算完成。

例子:并行计算数组的和。

Java代码  收藏代码
  1. package  executorservice;  
  2.   
  3. import  java.util.ArrayList;  
  4. import  java.util.List;  
  5. import  java.util.concurrent.Callable;  
  6. import  java.util.concurrent.ExecutionException;  
  7. import  java.util.concurrent.ExecutorService;  
  8. import  java.util.concurrent.Executors;  
  9. import  java.util.concurrent.Future;  
  10. import  java.util.concurrent.FutureTask;  
  11.   
  12. public   class  ConcurrentCalculator {  
  13.   
  14.     private  ExecutorService exec;  
  15.     private   int  cpuCoreNumber;  
  16.     private  List<Future<Long>> tasks =  new  ArrayList<Future<Long>>();  
  17.   
  18.     // 内部类   
  19.     class  SumCalculator  implements  Callable<Long> {  
  20.         private   int [] numbers;  
  21.         private   int  start;  
  22.         private   int  end;  
  23.   
  24.         public  SumCalculator( final   int [] numbers,  int  start,  int  end) {  
  25.             this .numbers = numbers;  
  26.             this .start = start;  
  27.             this .end = end;  
  28.         }  
  29.   
  30.         public  Long call()  throws  Exception {  
  31.             Long sum = 0l;  
  32.             for  ( int  i = start; i < end; i++) {  
  33.                 sum += numbers[i];  
  34.             }  
  35.             return  sum;  
  36.         }  
  37.     }  
  38.   
  39.     public  ConcurrentCalculator() {  
  40.         cpuCoreNumber = Runtime.getRuntime().availableProcessors();  
  41.         exec = Executors.newFixedThreadPool(cpuCoreNumber);  
  42.     }  
  43.   
  44.     public  Long sum( final   int [] numbers) {  
  45.         // 根据CPU核心个数拆分任务,创建FutureTask并提交到Executor   
  46.         for  ( int  i =  0 ; i < cpuCoreNumber; i++) {  
  47.             int  increment = numbers.length / cpuCoreNumber +  1 ;  
  48.             int  start = increment * i;  
  49.             int  end = increment * i + increment;  
  50.             if  (end > numbers.length)  
  51.                 end = numbers.length;  
  52.             SumCalculator subCalc = new  SumCalculator(numbers, start, end);  
  53.             FutureTask<Long> task = new  FutureTask<Long>(subCalc);  
  54.             tasks.add(task);  
  55.             if  (!exec.isShutdown()) {  
  56.                 exec.submit(task);  
  57.             }  
  58.         }  
  59.         return  getResult();  
  60.     }  
  61.   
  62.     /**  
  63.      * 迭代每个只任务,获得部分和,相加返回  
  64.      *   
  65.      * @return  
  66.      */   
  67.     public  Long getResult() {  
  68.         Long result = 0l;  
  69.         for  (Future<Long> task : tasks) {  
  70.             try  {  
  71.                 // 如果计算未完成则阻塞   
  72.                 Long subSum = task.get();  
  73.                 result += subSum;  
  74.             } catch  (InterruptedException e) {  
  75.                 e.printStackTrace();  
  76.             } catch  (ExecutionException e) {  
  77.                 e.printStackTrace();  
  78.             }  
  79.         }  
  80.         return  result;  
  81.     }  
  82.   
  83.     public   void  close() {  
  84.         exec.shutdown();  
  85.     }  
  86. }  

 Main

Java代码  收藏代码
  1. int [] numbers =  new   int [] {  1 2 3 4 5 6 7 8 10 11  };  
  2. ConcurrentCalculator calc = new  ConcurrentCalculator();  
  3. Long sum = calc.sum(numbers);  
  4. System.out.println(sum);  
  5. calc.close();  

 四、CompletionService

在刚在的例子中,getResult()方法的实现过程中,迭代了FutureTask的数组,如果任务还没有完成则当前线程会阻塞,如果我们希望 任意字任务完成后就把其结果加到result中,而不用依次等待每个任务完成,可以使CompletionService。生产者submit()执行的 任务。使用者take()已完成的任务,并按照完成这些任务的顺序处理它们的结果 。也就是调用CompletionService的take方法是,会返回按完成顺序放回任务的结果,CompletionService内部维护了一个 阻塞队列BlockingQueue,如果没有任务完成,take()方法也会阻塞。修改刚才的例子使用CompletionService:

Java代码  收藏代码
  1. public   class  ConcurrentCalculator2 {  
  2.   
  3.     private  ExecutorService exec;  
  4.     private  CompletionService<Long> completionService;  
  5.   
  6.   
  7.     private   int  cpuCoreNumber;  
  8.   
  9.     // 内部类   
  10.     class  SumCalculator  implements  Callable<Long> {  
  11.         ......  
  12.     }  
  13.   
  14.     public  ConcurrentCalculator2() {  
  15.         cpuCoreNumber = Runtime.getRuntime().availableProcessors();  
  16.         exec = Executors.newFixedThreadPool(cpuCoreNumber);  
  17.         completionService = new  ExecutorCompletionService<Long>(exec);  
  18.   
  19.   
  20.     }  
  21.   
  22.     public  Long sum( final   int [] numbers) {  
  23.         // 根据CPU核心个数拆分任务,创建FutureTask并提交到Executor   
  24.         for  ( int  i =  0 ; i < cpuCoreNumber; i++) {  
  25.             int  increment = numbers.length / cpuCoreNumber +  1 ;  
  26.             int  start = increment * i;  
  27.             int  end = increment * i + increment;  
  28.             if  (end > numbers.length)  
  29.                 end = numbers.length;  
  30.             SumCalculator subCalc = new  SumCalculator(numbers, start, end);   
  31.             if  (!exec.isShutdown()) {  
  32.                 completionService.submit(subCalc);  
  33.   
  34.   
  35.             }  
  36.               
  37.         }  
  38.         return  getResult();  
  39.     }  
  40.   
  41.     /**  
  42.      * 迭代每个只任务,获得部分和,相加返回  
  43.      *   
  44.      * @return  
  45.      */   
  46.     public  Long getResult() {  
  47.         Long result = 0l;  
  48.         for  ( int  i =  0 ; i < cpuCoreNumber; i++) {              
  49.             try  {  
  50.                 Long subSum = completionService.take().get();  
  51.                 result += subSum;             
  52.             } catch  (InterruptedException e) {  
  53.                 e.printStackTrace();  
  54.             } catch  (ExecutionException e) {  
  55.                 e.printStackTrace();  
  56.             }  
  57.         }  
  58.         return  result;  
  59.     }  
  60.   
  61.     public   void  close() {  
  62.         exec.shutdown();  
  63.     }  
  64. }  

 五、例子HtmlRender

该例子模拟浏览器的Html呈现过程,先呈现文本,再异步下载图片,下载完毕每个图片即显示,见附件eclipse项目htmlreander包。

 

所有代码见附件,Eclipse项目。本文参考《Java并发编程实践 》。

 

分享到:
评论

相关推荐

    java并发编程-从入门到精通

    Java并发编程是Java开发者必须掌握的关键技能之一,尤其是在开发高性能、多线程的应用时。本教程“java并发编程-从入门到精通”旨在帮助你深入理解这个领域,并逐步提升你的编程能力。 首先,我们要理解Java并发的...

    java并发编程实战源码,java并发编程实战pdf,Java

    《Java并发编程实战》是Java并发编程领域的一本经典著作,它深入浅出地介绍了如何在Java平台上进行高效的多线程编程。这本书的源码提供了丰富的示例,可以帮助读者更好地理解书中的理论知识并将其应用到实际项目中。...

    java并发编程-构建块

    "java并发编程-构建块"这个主题涵盖了使程序能够同时处理多个任务的关键概念和技术。在这个主题下,我们将深入探讨Java中用于构建高效并发应用的核心工具和概念。 1. **线程**:Java中的线程是并发编程的基础,每个...

    Java 并发编程实战.pdf

    《Java并发编程实战》这本书是关于Java语言中并发编程技术的经典著作。它详细介绍了如何在Java环境中有效地实现多线程程序和并发控制机制。在Java平台上,由于其本身提供了强大的并发编程支持,因此,掌握并发编程...

    Java并发编程利器:Executor框架深度解析与应用实践

    在现代Java应用开发中,多线程并发编程已成为提升程序性能的关键技术之一。Java通过引入Executor框架,为并发任务的执行提供了一种高效、灵活的管理机制。本文将深入探讨Executor框架的设计哲学、核心组件,并结合...

    Java-Executor并发框架.docx

    Java并发框架中的Executor服务是Java 1.5引入的核心组件,位于`java.util.concurrent`包下,极大地简化了多线程编程。Executor接口虽然历史悠久,但其重要性不言而喻,很多开发者对其背后的原理并不十分了解。本文将...

    java 并发编程的艺术pdf清晰完整版 源码

    《Java并发编程的艺术》这本书是Java开发者深入理解并发编程的重要参考书籍。这本书全面地介绍了Java平台上的并发和多线程编程技术,旨在帮助开发者解决在实际工作中遇到的并发问题,提高程序的性能和可伸缩性。 ...

    JAVA并发编程实践-中文-高清-带书签-完整版

    《JAVA并发编程实践》是Java开发人员深入理解并发编程的一本经典著作,由Doug Lea撰写,本书中文版高清完整,包含丰富的书签,便于读者查阅和学习。这本书旨在帮助开发者掌握在Java平台上进行高效、安全并发编程的...

    13-Java并发编程学习宝典.zip

    Java并发编程是软件开发中的重要领域,特别是在大型系统和高并发场景中不可或缺。"13-Java并发编程学习宝典.zip" 包含了一系列关于Java并发编程的学习资源,旨在帮助开发者掌握多线程编程的核心技术和最佳实践。以下...

    JAVA并发编程艺术pdf版

    《JAVA并发编程艺术》是Java开发者深入理解和掌握并发编程的一本重要著作,它涵盖了Java并发领域的核心概念和技术。这本书详细阐述了如何在多线程环境下有效地编写高效、可靠的代码,对于提升Java程序员的技能水平...

    java并发编程内部分享PPT

    Java并发编程是Java开发中的重要领域,特别是在多核处理器和分布式系统中,高效地利用并发可以极大地提升程序的性能和响应速度。这份“java并发编程内部分享PPT”显然是一个深入探讨这一主题的资料,旨在帮助开发者...

    Java 并发编程实战-随书源码

    《Java并发编程实战》这本书是Java开发者深入理解并发编程的重要参考书籍。本书旨在帮助程序员解决在多线程环境中遇到的实际问题,提升系统性能并保证其稳定性。随书源码提供了丰富的示例,让读者能够动手实践,加深...

    Java并发编程-并发编程知识点总结.docx

    ### Java并发编程知识点总结 #### 1. 什么是线程? 线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位。程序员可以通过线程进行多处理器编程,利用多线程对运算密集型任务...

    Java并发编程从入门到精通(pdf)(附源码)

    《Java并发编程从入门到精通》是一本专为Java开发者设计的深度学习并发编程的书籍。作者韩剑锋,凭借其12年的IT行业经验,曾担任多家IT公司的研发总监和技术总监,以其丰富的实战经验和深厚的理论知识,为读者提供了...

    java并发编程书籍

    Java并发编程是软件开发中的一个关键领域,尤其是在大型企业级应用和分布式系统中。通过学习相关的书籍,开发者可以深入理解如何有效地设计和实现高效的多线程应用程序,避免并发问题,如竞态条件、死锁、活锁等。...

    《Java并发编程的艺术》

    《Java并发编程的艺术》内容涵盖Java并发编程机制的底层实现原理、Java内存模型、Java并发编程基础、Java中的锁、并发容器和框架、原子类、并发工具类、线程池、Executor框架等主题,每个主题都做了深入的讲解,同时...

    Java并发编程实践.pdf

    ### Java并发编程实践 #### 一、并发编程基础 ##### 1.1 并发与并行的区别 在Java并发编程中,首先需要理解“并发”(Concurrency)和“并行”(Parallelism)的区别。“并发”指的是多个任务在同一时间段内交替...

    Java并发编程实践-电子书1-9章pdf

    《Java并发编程实践》是Java开发者深入理解并发编程的重要参考资料,尤其对于想要提升多线程应用设计和性能优化技能的程序员来说,这本书提供了丰富的实践经验和深入的理论知识。以下是根据提供的章节内容概述的一些...

    [Java并发编程实践].(Java.Concurrency.in.Practice).Brian.Goetz.英文原版.pdf

    ### Java并发编程实践 #### 书籍概述 《Java并发编程实践》是一本由Brian Goetz等人编写的关于Java并发编程的经典著作。本书深入浅出地介绍了Java 5.0及之后版本中新增加的并发特性,并对并发编程进行了全面而详尽...

Global site tag (gtag.js) - Google Analytics