Java并发----Callable、Future和FutureTask

最新推荐文章于 2022-09-01 10:39:28 发布
最新推荐文章于 2022-09-01 10:39:28 发布
阅读量543 收藏 1
点赞数
分类专栏： JAVA Bacis Content 文章标签： 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25223941/article/details/52921979
版权

Callable、Future和FutureTask

创建线程一般使用Thread或者实现Runnable接口，这种缺陷是执行完毕之后是无法获取到结果的。（run()返回是void）。
如果想获取到结果需要使用共享变量或者线程之间的通信获取，如此做不仅繁琐对编程能力有要求比较高。
从JAVA1.5提供了Callable、Future来使线程执行完毕之后返回结果。



下面是我总结的使用Callable、Future和FutureTask的使用方法：

1.Callable位于java.util.concurrent包，里面只声明了一个方法call();(类似run()，但是它是有返回结果类型的--V)； 
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}
一般配合ExecutorService类来使用，这个类中有submit方法： 
<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);
一般情况下我们只使用第一个和第三个，第二个很少使用。
它们返回的都是Future，我们来看看这个是怎么使用的。

2.Future
Future就是对Callable和Runnable任务的执行结果进行取消、查询是否完成、获取结果等操作。必要时可通过get()获取结果，任务阻塞直到任务返回结果。

Future类位于java.util.concurrent包下： 
public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}
cancel方法用来取消任务，如果任务取消则返回成功true，否则返回fasle。-----mayInterruptIfRunning表示是否允许取消正在执行但没有执行完毕的任务，如果设置true，则表示允许取消。

isCancelled方法表示任务是否被取消成功。

isDone方法表示任务是否已经完成。

get方法表示用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回。

get（long timeout,TimeUnit unit）用来获取执行结果，如果在指定时间内未获取到则直接返回null。

此接口定义了许多对线程执行结果的一些验证和返回。具体实现类FutureTask才是核心。

3.FutureTask
FutureTask是Future接口的唯一实现类。
它实现了RunnableFuture接口，而这接口又继承了Runnable和Future接口。所以它可作为Runnable被线程执行，又可以作为Callable的返回值。


-------------------------------------------  使用案例  -------------------------------------------------

使用Callable和Future获取执行结果： 
	List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
<span style="white-space:pre">		</span>Map<String, Object> params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果1");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果2");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果3");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果4");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果5");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果6");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果7");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果8");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果9");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果10");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果11");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果12");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果13");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果14");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果15");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果16");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果17");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果18");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果19");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>params = new HashMap<String, Object>();
<span style="white-space:pre">		</span>params.put("taskName", "结果20");
<span style="white-space:pre">		</span>list.add(params);
<span style="white-space:pre">		</span>Task<String> task = new SendTask();
<span style="white-space:pre">		</span>long start = System.currentTimeMillis();
<span style="white-space:pre">		</span>List<Future<String>> results = TaskHandler.dealTask(list, task,10000);
<span style="white-space:pre">		</span>long end = System.currentTimeMillis();
<span style="white-space:pre">		</span>System.out.println(end-start);
<span style="white-space:pre">		</span>int i=0;
<span style="white-space:pre">		</span>for (Future<String> f : results) {
<span style="white-space:pre">			</span>i++;
<span style="white-space:pre">			</span>System.out.println("返回结果："+i);
<span style="white-space:pre">			</span>try {
<span style="white-space:pre">				</span>System.out.println(f.get());
<span style="white-space:pre">			</span>} catch (Exception e) {
<span style="white-space:pre">				</span>e.printStackTrace();
<span style="white-space:pre">			</span>}
<span style="white-space:pre">		</span>}


 
public class SendTask implements Task<String>{
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>private Map<String, Object> params;
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>@Override
<span style="white-space:pre">	</span>public void taskParams(Map<String, Object> params) {
<span style="white-space:pre">		</span>this.params = params;
<span style="white-space:pre">	</span>}


<span style="white-space:pre">	</span>@Override
<span style="white-space:pre">	</span>public String call() throws Exception {
<span style="white-space:pre">		</span>System.out.println("线程等待2s");
<span style="white-space:pre">		</span>Thread.sleep(2000);
<span style="white-space:pre">		</span>System.out.println(params.get("taskName"));
<span style="white-space:pre">		</span>return "返回成功！";
<span style="white-space:pre">	</span>}


}

 
public static  <T>List<Future<T>> dealTask(List<Map<String, Object>> params,Task<T> task,long timeOut){
		List<Future<T>> list = new ArrayList<Future<T>>();
		//获取缓存线程池
		ExecutorService service = ThreadLocalHelper.getCachedPool();
		// 执行多任务,循环处理参数集
		Future<T> future = null;
		//初始化返回结果集
		for (Map<String, Object> param : params) {
			try {
				// 给任务设置任务参数
				task.taskParams(param);
				//执行任务
				future = service.submit(task);
				list.add(future);
			} catch (Exception e) {
				e.printStackTrace();
			} 
		}
		//执行完毕后关闭线程池
		service.shutdown();
		//获取开始时间（若超过20S，则强制退出返回）
		long start = System.currentTimeMillis();
		long flag = 0;
		while(true){
			flag = System.currentTimeMillis()-start;
			if(service.isTerminated()||flag>=timeOut){
				System.out.println("线程执行完毕!");
				break;
			}
			try {
				Thread.sleep(10);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return list;
	}




















Cx_轩
关注
专栏目录
Java并发编程（1）- Callable、Future和FutureTask
青松之竹_Java博客
12-17 298
撸过JavaSE（即Java基础技术栈）的小伙伴都知道，实现多线程有两种方式，一种是继承Thread,即extends Thread然后实现其中的run()方法；另外一种是实现Runnable接口，即implements Runnable，然后实现其中的run()方法；仔细观察这两种方式，会发现这两者都不能返回线程异步执行完的结果，但在实际项目开发中却偶尔需要获取其中的返回结果，咋办嘞？于是乎Callable和Future就排上用场了，本文我们将对其做一番详尽的介绍！ 还是先介绍下多线程的传统实现方式吧.
FutureTask的简单使用
qq_33730729的博客
03-19 403
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(5);//销售sku(按sku分) FutureTask&lt;List&lt;Map&lt;String, Object&gt;&gt; &gt; getSales = new FutureTask&lt;List&lt;Map&lt;String, O...
并发编程学习笔记之线程池(五)
weixin_30426957的博客
10-16 89
单线程的缺点&使用多线程的好处 围绕执行任务来管理应用程序时,第一步要指明一个清晰的任务边界(task boundaries).理想情况下,任务是独立的活动:它的工作并不依赖于其他任务的状态、结果或者边界效应.独立有利于并发性,如果能得到相应的处理器资源,独立的任务还可以并行执行. 在正常的负载下,服务器应用程序应该兼具良好的吞吐量和快速的响应性.应用程序提供商希望程序支持尽可能...
FutureTask详解
田野中的锋芒
08-20 6226
Future接口和实现Future接口的FutureTask类，代表异步计算的结果。 FutureTask简介 FutureTask除了实现Future接口外，还实现了Runnable接口。因此，FutureTask可以交给 Executor执行，也可以由调用线程直接执行（FutureTask.run()）。根据FutureTask.run()方法被执行 的时机，FutureTask可以处于下...
java Callable使用实例
写博客只为学习
04-26 368
[color=red][size=large]多个线程实现累加[/size][/color] [code="java"] package com.thread; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurr...
Java[学习总结]-多线程（二）之Callable和FutureTask
qq_43502987的博客
12-18 647
1.使用意义 从JDK1.5之后，Java提供了Callable接口，实|际_上就是Runnable接口的增强版。提供call方 法作为线程执行体，但是功能更加强大。Call方法可以有返回值，Call方法可以抛出异常。 public interface Callable<V>{ V call() throws Exception; . } 2.使用Future （1）在并发编程时，一般使用runnable,然后给线程池，这种情况下不需要线程的结果。所以run（）的返回值是void类型。如果是一
Java 多线程与并发(17-26)-JUC线程池- FutureTask详解.pdf
最新发布
07-28
`FutureTask`是Java并发库中的一个关键组件，它实现了`RunnableFuture`接口，能够作为`Runnable`接口的实现被线程执行，同时也继承了`Future`接口，用于获取计算的结果。`FutureTask`的设计使得我们可以更加灵活地...
Java并发-CountDownLatch、CyclicBarrier、Semaphore、Runnable、Callable、Future、FutureTask总结记录
Muscleape的博客
04-19 403
1、CountDownLatch、CyclicBarrier、Semaphore，都位于java.util.concurrent包中，是并发控制的辅助类，可以控制线程的协同工作； 2、Runnable（java.lang.Runnable）、Callable（java.util.concurrent），作为线程创建相关类； 3、Future（java.util.concurrent），是对于具体...
Java中的Runnable，Callable，Future，FutureTask的比较
08-31
Java中的Runnable、Callable、Future和FutureTask是Java多线程编程中的核心概念，它们各自扮演着不同的角色，共同协作以实现并发任务的管理和执行。 1. **Runnable**: Runnable是最基本的多线程接口，它只有一个`...
FutureTask的用法及两种常用的使用场景
青年IT男
06-27 2209
FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方...
ThreadPoolExecutor和Callable的应用
帅性而为1号的博客
03-19 2060
一、Responsepublic class Response&lt;T&gt; implements Serializable { private String key; private T response; public Response(String key, T response) { this.key = key; ...
线程池使用Callable示例【我】
weixin_30802273的博客
07-26 200
实际工作中可以把下面的代码直接拿过去改改即可 package threadtest; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.concurrent.Callable; ...
多线程执行任务
ZgqJavaCSDN的博客
06-10 220
/* 业务逻辑处理 */ public class ATask implements Callable<Map<String, Object>> { private Map<String, Object> aMap; public ATask(Map<String, Object> aMap) { this.aMap = aMap; } public Map<String, Object> call() throws Ex.
Java 1.8 stream 集合根据某字段排序
热门推荐
Cx的博客
09-01 1万+
【代码】Java 1.8 stream 集合根据某字段排序。 sort
JAVA--HashCode 基础（判断对象是否相等）
Cx的博客
11-18 8011
HashCode基础 hashCode在JAVA中，代表了对象的一种特征。不同的对象哈希码是不同的。 哈希码是一种数据结构算法，在JAVA中，常见的哈希码算法获取到的哈希码具体值是怎么获取到的呢？ 来分析一下： 1.在String类中的hashCode是根据String类中包含的字符串获取的，根据哈希算法获取到一个哈希码，那么只要我的字符内容是相等的，我的哈希码也是相同的。eg: pub
JAVA GC---新生代、老年代
Cx的博客
02-22 6775
GC新生代、老年代 Java堆中是JVM管理的最大一块内存空间。主要存放对象实例。 在JAVA中堆被分为两块区域：新生代（young）、老年代（old）。 堆大小=新生代+老年代；（新生代占堆空间的1/3、老年代占堆空间2/3） 新生代又被分为了eden、from survivor、to survivor(8:1:1)； 新生代这样划分是为了更好的管理堆内存中的对象，方便GC算法--
Eclipse快捷键的设置和使用（大小写快捷键等）
Cx的博客
11-10 6183
Eclipse快捷键的设置和使用 一．查看或设置所有的快捷键设置 1、点击window菜单->preferences->general->keys，进入快捷键管理界面 2、在这里可以查找所有功能的快捷键，需要修改或新增时，点击需要修改或新增的命令，在binding里设置快捷键 二．默认快捷键的使用 1、alt+?或alt+/：自动补全代码或者提示代码 2、ctrl+o：快速outline视图 3、ctrl+shift+r：打开资源列表 4、ctrl+shift+f：
Java并发编程：详解Callable与Future接口及其应用
Java并发编程中的Callable和Future是两个关键的概念，它们在处理异步操作和线程池执行时提供了一种强大的工具。Callable和Future的主要作用在于允许开发者在并发环境中进行有返回值的操作，并且能够控制任务的执行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值