Java并发之Executor + Callable + Future

最新推荐文章于 2021-07-24 13:17:07 发布
最新推荐文章于 2021-07-24 13:17:07 发布
阅读量89 收藏
点赞数
文章标签： java
原文链接：https://juejin.im/post/5a3b3a25f265da4311205f37
版权
  • 引入 Callable + Future
  • Callable + Future实例

引入 Callable + Future

Executor框架的优势之一就是，可以运行并发任务并且返回结果。 我们知道Runnable对象是没有返回值的，所以自然利用Runnable对象就无法返回结果，于是就定义了一个新的接口，可以理解为是“带有返回值的Runnable对象”。 这个接口就是 Callable接口：这个接口声明了一个call方法，类似于Runnable接口的run方法，是任务具体的逻辑，不同就在于可以有返回值，而且这个接口是一个泛型接口，这就意味着必须声明call方法的返回类型。

我们任务交给线程执行之后，什么时候执行结束，将结果返回这个时间往往是无法具体确定的，所以为了接受这个来自未来某个时刻执行完之后的返回结果，又新增了一个Future接口： Future接口：这个接口声明了一些方法获取由callable对象产生的结果，并管理他们的状态。

Callable + Future实例

接下来，我们编写一个实例来接受任务的返回结果

实现一个Callable对象，由于返回值是Integer，所以定义为Callable

package CreateExecutorCallableFuture;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class FactorialCaculator implements Callable<Integer> {
	
	private Integer number;
	
	

	public FactorialCaculator(Integer number) {
		super();
		this.number = number;
	}



	@Override
	public Integer call() throws Exception {
		int result = 1;
		if((number == 0) || (number == 1))
			return 1;
		else {
			for(int i=2;i<=number;i++) {
				result *= i;
				TimeUnit.MILLISECONDS.sleep(20);
			}
		}
		
		System.out.printf("%s : %d\n",Thread.currentThread().getName(),result);
		
		return result;
	}
	
}
复制代码

Main类创建一个线程池来执行这些任务，并在任务执行完之后输出结果

package CreateExecutorCallableFuture;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {

	public static void main(String[] args) throws InterruptedException {
		ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newFixedThreadPool(2);
		List<Future<Integer>> resList = new ArrayList<>();
		
		Random random = new Random();
		
		for(int i=0;i<10;i++) {
			Integer number = random.nextInt(10);
			FactorialCaculator caculator = new FactorialCaculator(number);
			
			Future<Integer> res = executor.submit(caculator);
			resList.add(res);
		}
		
		do {
			System.out.println("Main : Number of CompleteTasks : " + executor.getCompletedTaskCount());
			for(int i=0;i<resList.size();i++) {
				Future<Integer> res = resList.get(i);
				System.out.printf("Main : task %d : %s\n", i, res.isDone());
			}
			
			TimeUnit.MILLISECONDS.sleep(50);
			
		}while(executor.getCompletedTaskCount() < resList.size());
		
		for(int i=0;i<resList.size();i++) {
			Future<Integer> res = resList.get(i);
			Integer number = null;
			try {
				number = res.get();
			} catch (ExecutionException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.printf("Main : Task %d : %s\n",i,number);
		}
	}

}
复制代码

运行结果

Main : Number of CompleteTasks : 0
Main : task 0 : false
Main : task 1 : false
Main : task 2 : false
Main : task 3 : false
Main : task 4 : false
Main : task 5 : false
Main : task 6 : false
Main : task 7 : false
Main : task 8 : false
Main : task 9 : false
pool-1-thread-1 : 24
pool-1-thread-2 : 120
Main : Number of CompleteTasks : 2
Main : task 0 : true
Main : task 1 : true
Main : task 2 : false
Main : task 3 : false
Main : task 4 : false
Main : task 5 : false
Main : task 6 : false
Main : task 7 : false
Main : task 8 : false
Main : task 9 : false
pool-1-thread-2 : 2
pool-1-thread-2 : 2
Main : Number of CompleteTasks : 4
Main : task 0 : true
Main : task 1 : true
Main : task 2 : false
Main : task 3 : true
Main : task 4 : true
Main : task 5 : false
Main : task 6 : false
Main : task 7 : false
Main : task 8 : false
Main : task 9 : false
pool-1-thread-2 : 6
Main : Number of CompleteTasks : 6
Main : task 0 : true
Main : task 1 : true
Main : task 2 : false
Main : task 3 : true
Main : task 4 : true
Main : task 5 : true
Main : task 6 : true
Main : task 7 : false
Main : task 8 : false
Main : task 9 : false
pool-1-thread-1 : 40320
Main : Number of CompleteTasks : 7
Main : task 0 : true
Main : task 1 : true
Main : task 2 : true
Main : task 3 : true
Main : task 4 : true
Main : task 5 : true
Main : task 6 : true
Main : task 7 : false
Main : task 8 : false
Main : task 9 : false
pool-1-thread-2 : 720
Main : Number of CompleteTasks : 9
Main : task 0 : true
Main : task 1 : true
Main : task 2 : true
Main : task 3 : true
Main : task 4 : true
Main : task 5 : true
Main : task 6 : true
Main : task 7 : true
Main : task 8 : false
Main : task 9 : true
Main : Number of CompleteTasks : 9
Main : task 0 : true
Main : task 1 : true
Main : task 2 : true
Main : task 3 : true
Main : task 4 : true
Main : task 5 : true
Main : task 6 : true
Main : task 7 : true
Main : task 8 : false
Main : task 9 : true
pool-1-thread-1 : 362880
Main : Task 0 : 24
Main : Task 1 : 120
Main : Task 2 : 40320
Main : Task 3 : 2
Main : Task 4 : 2
Main : Task 5 : 6
Main : Task 6 : 1
Main : Task 7 : 720
Main : Task 8 : 362880
Main : Task 9 : 1
复制代码

Future对象主要有一下两个目的：

  • 控制任务的状态：可以取消和检查任务是否完成。可以使用isDone检查任务是否完成，检查isCancel检查任务是否暂停，也可以直接调用cancle方法暂停任务。

  • 通过call方法获取返回结果，为了达到这个目的，可以使用get方法，这个方法会一直等到callable对象的call方法返回结果。如果此时任务尚未完成，get方法就会一直阻塞到线程完成。

** Future对象是用来管理Callavle任务的！**

weixin_33691817
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程之Executor框架「Callable、Future和Executor」
AD_plus的博客
07-22 629
引言 Executor框架是指JDK 1.5中引入的一系列并发库中与Executor相关的功能类，包括Executor、Executors、ExecutorService、Future、Callable等。 一、为什么要引入Executor框架？ 1、如果使用new Thread(…).start()的方法处理多线程，有如下缺点： ① 开销大。对于JVM来说，每次新建线程和销毁线程都会有很大的开销...
Executor、Callable、Future、Lock、辅助类、CompletableFuture
weixin_44677487的博客
11-30 363
文章目录Executor框架浅析Executor框架的两级调度模型Executor框架的结构参考 Executor框架浅析 首先我们得明白一个问题，为什么需要线程池？在java中，使用线程来执行异步任务时，线程的创建和销毁需要一定的开销，如果我们为每一个任务创建一个新的线程来执行的话，那么这些线程的创建与销毁将消耗大量的计算资源。同时为每一个任务创建一个新线程来执行，这样的方式可能会使处于高负荷状态的应用最终崩溃。所以线程池的出现为解决这个问题带来曙光。我们将在线程池中创建若干条线程，当有任务需要执行时就
Java - 多线程Callable、Executors、Future
chuange6363的博客
08-14 91
http://blog.csdn.net/pipisorry/article/details/44341579 Introduction Callable接口代表一段可以调用并返回结果的代码; Future接口表示异步任务，是还没有完成的任务给出的未来结果。 所以Callable用于产...
Python 第八节 第八课
我是小白呀的博客
10-05 655
[toc] 重写 __str__() 方法 object 有一个 __str__() 方法, 用于返回一个对于 "对象的描述", 对于内置函数 str() 经常用于 print() 方法, 帮助我们查看对象信息. __str__() 可以重写. 执行结果:
callable，Executor，Future
lin20080410的专栏
08-31 262
转：http://blog.csdn.net/zhangzhaokun/article/details/6615454   在再度温习Java5的并发编程的知识点时发现，首要的就是把Runnable、Callable、Executor、Future等的关系搞明白，遂有了下述小测试程序，通过这个例子上述三者的关系就一目了然了。 在java5以后，一个可以调度执行的线程单元可以有三种方式定义：
java callable future_java:并发编程-Callable与Future模式
weixin_42131261的博客
02-16 109
自己对线程池的理解：coresize 3maxsize 5blockLinkedQuenue 3当提交的任务在<=3时，创建三个线程干活大于3时，把任务先加入阻塞式队列，当有空闲的核心线程便去执行他们，队列中的任务执行是实际运行的线程在复用执行如果后面有提交了很多任务，队列都放不下了，就赶紧创建新的线程去执行他们，如果任务已经大于了>队列+最大线程数,没有能力干活了，只能崩塌了，抛出拒...
Java并发框架:Executor API详解
08-25
Java并发框架中的Executor API是Java多线程编程的重要组成部分，它是Java从JDK 1.5版本开始引入的，旨在提供一种更高效、更可控的线程管理方式。Executor API的核心在于`java.util.concurrent.Executor`接口，它定义...
concurrent-csv-parser:使用 Executor 和 Callable-Future 进行并发任务处理
06-02
技术方案基于ExecutorService、Callable、Future等高级Java并发API。 技术栈 JDK 8 Apache Maven v.3.2 构建说明 从应用程序根目录调用以下 maven 命令： mvn clean package 检查构建日志，确保构建成功： ...
java并发编程实战源码,java并发编程实战pdf,Java
09-10
4. **线程池**：Java的Executor框架提供了一种管理线程的方式，通过ThreadPoolExecutor可以创建线程池，有效控制并发线程的数量，避免系统资源的过度消耗。 5. **并发集合**：Java的并发集合类库，如...
java并发源码分析之实战编程
最新发布
11-17
首先，Java并发库（java.util.concurrent）是Java并发编程的核心，提供了多种高级并发结构，如Executor框架、Future、Callable接口等。Executor框架通过将任务与执行分离，简化了多线程编程。ThreadPoolExecutor是其...
Java中的Runnable，Callable，Future，FutureTask的比较
08-31
Java中的Runnable、Callable、Future和FutureTask是Java多线程编程中的核心概念，它们各自扮演着不同的角色，共同协作以实现并发任务的管理和执行。 1. **Runnable**: Runnable是最基本的多线程接口，它只有一个`...
Runnable、Callable、Executor、Future、FutureTask关系解读
热门推荐
张兆坤
07-18 2万+
在再度温习Java5的并发编程的知识点时发现，首要的就是把Runnable、Callable、Executor、Future等的关系搞明白，遂有了下述小测试程序，通过这个例子上述三者的关系就一目了然了。 在java5以后，一个可以调度执行的线程单元可以有三种方式定义： Thread、Runnable、Callable，其中Runnable实现的是void run()方法，Callable实现的
java并发----java线程池，Executor框架，Callable，Future
人在江湖
06-09 745
前言 本文章适合新手对线程池的认识=0的同学，不涉及源码，仅从应用层次来讲，是笔者的资料整理，每一个都有相应的实例 主要内容 线程池的类型，区别，特点 线程池如何提交runnable任务和callable任务。 线程池所使用的队列（有界，无界） 线程池满的策略 自定义线程 why？ 其实每次学习一个新知识的时候，我们都需要知道为什么要使用它？ 通俗概括： 创建线程T1时间，线...
JAVA并行异步编程,线程池+FutureTask+callable+ExecutorService
寒江的专栏
05-26 1万+
java 在JDK1.5中引入一个新的并发包java.util.concurrent 该包专门为java处理并发而书写。 在java中熟悉的使用多线程的方式为两种？继续Thread类，实现Runnale。两种方式简单方便。 在Jdk1.5之后其实有第三种方式实现方式，采用并发包中的 Callable接口 FuruteTask类 以及 ExecutorService接口。 说新的实
Java并发编程-Executor框架之Callable和Future接口
记忆力不好的博客
06-07 6437
在上一篇文章中我们已经了解了Executor框架进行线程管理，这篇文章将学习Executor框架的另一个特性，我们知道执行Runnable任务是没有返回值得，但Executor可以运行并发任务并获得返回值，Concurrent包提供下面两个接口实现这个功能： Callable接口：这个接口声明call()，类似于Runnable的run()，可以在这个方法里实现任务的具体逻辑操作。Callable是
使用ExecutorService、Callable、Future实现有返回结果的多线程 应用实例
3721程序人生
08-10 3254
以下是实践中应用到的多线程：    1、controller代码：     @RequestMapping(value = "/getTraingingUsersByTrainingIds", method = {RequestMethod.GET, RequestMethod.POST})     public void getTraingingUsersByTrainingId(
线程池Executors、Callable与Future的应用
豆豆
08-10 1526
package cn.itcast.heima;import java.util.Random; import java.util.concurrent.Callable; import java.util.concurrent.CompletionService; import java.util.concurrent.ExecutionException; import java.util.co
使用ExecutorService、Callable、Future实现有返回结果的线程
pdw2009的专栏
02-26 3280
 可返回值的任务必须实现Callable接口 无返回值的任务必须实现Runnable接口 执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object 注意：get方法是阻塞的，即：线程无返回结果，get方法会一直等待   例子1： /** * 有返回值的线程 */ @SuppressWarnings("unc...
Java并发基础(16)：线程池Executor框架
mingyuli的博客
07-24 413
下一篇：线程池
Java并发：Executor、Executors与ExecutorService详解
在Java并发编程中，Executor框架是一个重要的组件，它简化了线程的管理并提高了系统的并发性能。Executor是Java线程池的基石，它定义了一个单一的方法`execute(Runnable command)`，用于执行任务。然而，直接使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值