java并发编程-Executor框架1

最新推荐文章于 2025-08-14 09:11:10 发布
转载 最新推荐文章于 2025-08-14 09:11:10 发布 · 2.6k 阅读 · 1
文章标签：

#java #编程 #框架 #numbers #integer #exception

本文介绍了Java Executor框架的基本概念，包括线程池的创建方法、ExecutorService的生命周期管理以及如何使用Callable和Future获取异步计算结果。并通过实例展示了并行计算数组和的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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);   
Executor executor = Executors.newFixedThreadPool(10);
Runnable task = new Runnable() {
 @Override
 public void run() {
  System.out.println("task over");
 }
};
executor.execute(task);

executor = Executors.newScheduledThreadPool(10);
ScheduledExecutorService scheduler = (ScheduledExecutorService) executor;
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();   
ExecutorService executorService = (ExecutorService) executor;
while (!executorService.isShutdown()) {
 try {
  executorService.execute(task);
 } catch (RejectedExecutionException ignored) {
  
 }
}
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. }   
Callable<Integer> func = new Callable<Integer>(){
   public Integer call() throws Exception {
    System.out.println("inside callable");
    Thread.sleep(1000);
    return new Integer(8);
   }  
  };  
  FutureTask<Integer> futureTask  = new FutureTask<Integer>(func);
  Thread newThread = new Thread(futureTask);
  newThread.start();
  
  try {
   System.out.println("blocking here");
   Integer result = futureTask.get();
   System.out.println(result);
  } catch (InterruptedException ignored) {
  } catch (ExecutionException ignored) {
  }

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. }   
package executorservice;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class ConcurrentCalculator {

 private ExecutorService exec;
 private int cpuCoreNumber;
 private List<Future<Long>> tasks = new ArrayList<Future<Long>>();

 // 内部类
 class SumCalculator implements Callable<Long> {
  private int[] numbers;
  private int start;
  private int end;

  public SumCalculator(final int[] numbers, int start, int end) {
   this.numbers = numbers;
   this.start = start;
   this.end = end;
  }

  public Long call() throws Exception {
   Long sum = 0l;
   for (int i = start; i < end; i++) {
    sum += numbers[i];
   }
   return sum;
  }
 }

 public ConcurrentCalculator() {
  cpuCoreNumber = Runtime.getRuntime().availableProcessors();
  exec = Executors.newFixedThreadPool(cpuCoreNumber);
 }

 public Long sum(final int[] numbers) {
  // 根据CPU核心个数拆分任务，创建FutureTask并提交到Executor
  for (int i = 0; i < cpuCoreNumber; i++) {
   int increment = numbers.length / cpuCoreNumber + 1;
   int start = increment * i;
   int end = increment * i + increment;
   if (end > numbers.length)
    end = numbers.length;
   SumCalculator subCalc = new SumCalculator(numbers, start, end);
   FutureTask<Long> task = new FutureTask<Long>(subCalc);
   tasks.add(task);
   if (!exec.isShutdown()) {
    exec.submit(task);
   }
  }
  return getResult();
 }

 /**
  * 迭代每个只任务，获得部分和，相加返回
  * 
  * @return
  */
 public Long getResult() {
  Long result = 0l;
  for (Future<Long> task : tasks) {
   try {
    // 如果计算未完成则阻塞
    Long subSum = task.get();
    result += subSum;
   } catch (InterruptedException e) {
    e.printStackTrace();
   } catch (ExecutionException e) {
    e.printStackTrace();
   }
  }
  return result;
 }

 public void close() {
  exec.shutdown();
 }
}

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();  
Java并发编程 - Executor框架详解
congyh的专栏
03-07 785
Executor框架(接口)负责在用户级别进行任务的调度和执行, 实现了任务调度和执行的分离.Executor框架简介Executor框架的两级调度模型在上层, Java程序通过将应用分解为若干个任务(task), 然后使用用户级的调度器(Executor框架)将task映射为固定数量的Java线程.在底层, Java线程与操作系统的线程是一一对应的关系, 由操作系统调度给可用的CPU. 底层的调
Java并发编程利器：Executor框架深度解析与应用实践
10-16
在现代Java应用开发中，多线程并发编程已成为提升程序性能的关键技术之一。Java通过引入Executor框架，为并发任务的执行提供了一种高效、灵活的管理机制。本文将深入探讨Executor框架的设计哲学、核心组件，并结合...
Executor框架是指java 5中引入的一系列并发库中与executor相关的一些功能类，其中包括线程池，Executor，Executors，ExecutorService，Completion
facome的专栏
05-13 487
Executor框架是指java 5中引入的一系列并发库中与executor相关的一些功能类，其中包括线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callablehttp://www.iteye.com/topic/366591
java并发编程--Executor框架
moxiaolin的博客
04-29 397
对Executor框架简介 Executor框架实现了线程的提交和执行的解耦开发,易于扩展,采用线程中的生产者和消费者模式进行解耦开发,比如线程的提交相当于生产者,线程的执行相当于消费者. 1.Executor框架继承实现介绍: Executor的UML图: Executor:一个接口,只有一个接收runnable的构造方法: ExecutorService:比Executor...
java编程executor框架_java并发编程-Executor框架
weixin_42389522的博客
02-28 118
Executor框架是指java 5中引入的一系列并发库中与executor相关的一些功能类，其中包括线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。他们的关系为： 并发编程的一种编程方式是把任务拆分为一些列的小任务，即Runnable，然后在提交给一个Executor执行，Executor.exe...
java编程executor框架_java并发编程-Executor框架+Future
weixin_32311823的博客
02-28 227
Executor框架是指java 5中引入的一系列并发库中与executor相关的一些功能类，其中包括线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。他们的关系为：并发编程的一种编程方式是把任务拆分为一些列的小任务，即Runnable，然后在提交给一个Executor执行，Executor.exec...
java编程executor框架_Java并发编程-Executor框架集
weixin_35147304的博客
02-28 138
Executor框架集对线程调度进行了封装，将任务提交和任务执行解耦。它提供了线程生命周期调度的所有方法，大大简化了线程调度和同步的门槛。Executor框架集的核心类图如下：从上往下，可以很清晰的看出框架集的各个类，以及它们之间的关系：Executor，是一个可以提交可执行(Runnable)任务的Object，这个接口解耦了任务提交和执行细节(线程使用、调度等)，Executor主要用来替代显...
java编程executor框架_Java并发编程-Executor框架（转）
weixin_39831902的博客
02-28 149
本文转自http://blog.youkuaiyun.com/chenchaofuck1/article/details/51606224 感谢作者我们在传统多线程编程创建线程时，常常是创建一些Runnable对象，然后创建对应的Thread对象执行它们，但是如果程序需要并发执行大量的任务时，需要为每个任务都创建一个Thread，进行管理，这将会影响程序的执行效率，并且创建线程过多将会使系统负载过重。在JDK...
java编程executor框架_Java并发编程 - Executor框架（一）Executor，
weixin_39785286的博客
02-28 123
1、并发编程的一种编程方式是把任务拆分为一些列的小任务，即Runnable，然后将这些任务提交给一个Executor执行，Executor.execute(Runnalbe)。Executor在执行时使用其内部的线程池来完成操作。Executor的子接口有：ExecutorService,ScheduledExecutorService,已知实现类：AbstractExecutorServic...
主题：java并发编程-Executor框架
CWH615的博客
05-04 389
http://www.iteye.com/topic/366591
java并发编程-Executor框架
shoubuliaolebu的专栏
04-09 900
转自：http://www.iteye.com/topic/366591 Executor框架是指java 5中引入的一系列并发库中与executor相关的一些功能类，其中包括线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。他们的关系为：   并发编程的一种编程方式是把任务拆分为一些列
Java-Executor并发框架.docx
05-09
Java并发框架中的Executor服务是Java 1.5引入的核心组件，位于`java.util.concurrent`包下，极大地简化了多线程编程。Executor接口虽然历史悠久，但其重要性不言而喻，很多开发者对其背后的原理并不十分了解。本文将...
java并发编程实战源码-jcip-examples:java并发编程实战
05-25
《Java并发编程实战》是Java并发编程领域的一本经典之作，由Brian Goetz等作者撰写。这本书深入浅出地介绍了Java并发编程的各种概念和技术，帮助开发者理解和掌握如何在多线程环境中编写高效、安全的代码。jcip-...
Java并发之线程池Executor框架的深入理解
08-26
Java中的线程池Executor框架是Java并发编程中的一种常见机制，用于管理和执行异步任务。通过使用线程池，可以大大减少线程的创建和销毁开销，从而提高系统的性能和稳定性。 Executor框架是Java中的一个核心框架，...
Java并发编程-并发编程知识点总结.docx
04-19
### Java并发编程知识点总结 #### 1. 什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过线程进行多处理器编程，利用多线程对运算密集型任务...
C# 异步编程(BeginInvoke和EndInvoke)
钢铁男儿
08-11 530
在学习这些异步编程模式的示例之前，先研究一下Begin1nvoke和End1nvoke方法。有关Beginlnvoke的重要事项如下。如下的代码给出了一个调用委托的BeginInvoke方法的示例。第一行声明了叫作MyDeI的委托类型。下一行声明了一个和委托匹配的叫作sum的方法。EndInvoke方法用来获取由异步方法调用返回的值，并且释放线程使用的资源。EndInvoke有如下的特性。EndInvoke提供了异步方法调用的所有输出，包括ref和out参数。如果委托的引用方法有ref。
kmalloc
qq_24993025的博客
08-11 954
摘要： kmalloc是Linux内核中用于分配小块连续内存（≤4K）的核心机制，底层依赖slab（小内存）或buddysystem（大内存）。其分配策略为：≤8K从slab分配（预定义kmalloc_caches管理不同尺寸的slab，如8B~8K），>8K则直接调用buddysystem（最大支持4M）。内存地址通过内核启动时已建立线性映射（PA=VA-FixedOffset）。实现上，kmalloc通过编译优化区分常量/非常量请求，最终调用___kmalloc_large_node（buddysyst
Java 中 get 和 set 方法详解（更新版）
最新发布
Toroto5的博客
08-14 738
get 方法（访问器）和 set 方法（修改器）是面向对象编程中实现封装的关键技术。它们提供了一种标准化的方式来访问和修改类的私有成员变量。在 Java 等面向对象语言中，为了实现良好的封装性，通常会将类的成员变量声明为 private，然后通过 public 的 get 和 set 方法来操作这些变量。示例：一个完整的 User 类实现。
Linux学习-应用软件编程（文件IO）
2501_91684151的博客
08-12 1212
Linux内核专门为应用层提供的文件操作方式。1.打开文件 open2.读写文件 read/write3.关闭文件 close。
Java并发编程：Executor框架与线程池解析
"本章介绍了Java并发编程中的重要概念——线程池，以及相关的Executor框架。线程池在处理多任务并发执行时起到关键作用，能够有效提高系统性能，避免频繁创建和销毁线程的开销。Executor接口作为线程池的基础，用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值