Future<V>接口Callable<V>接口的使用

最新推荐文章于 2022-09-02 08:00:00 发布
转载 最新推荐文章于 2022-09-02 08:00:00 发布 · 269 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/u/1473861/blog/1607462
文章标签：

#java #python

本文介绍了Java并发编程中Future与Callable接口的应用，包括如何利用Future获取异步任务结果，以及如何通过CompletionService处理多个异步任务，确保按完成顺序处理结果。

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

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

在并发处理数据时，一个典型的场景是： 我们将需要处理的并且非常耗时的任务（例如访问网络IO）交给线程池中的一个线程去处理，我们当前的线程执行其他的任务，然后当交给线程池的任务执行完成后，我们再获取执行的结果，对得到的结果进处理，首选会充分利用CPU的多核资源，其次是将会阻塞的任务提前进行提交处理，尽量减少系统卡顿。（在互联网公司这样网络访问的方式非常常见。） 那么今天我们来谈一种新的实现方式Future<V>接口Callable<V>接口

Future<V>接口Callable<V>

在Future接口中声明了5个方法，下面依次解释每个方法的作用：

  1. cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
  2. isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
  3. isDone方法表示任务是否已经完成，若任务完成，则返回true；
  4. get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
  5. get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。 在callable接口中声明了1个方法，call()方法，主要用于执行你的操作，并放回操作后的值。

在callable接口中声明了1个方法，call()方法，主要用于执行你的操作，并放回操作后的值。 举个栗子 Future接口和Callable接口经常配合使用，废话不多说，上代码。

场景一

该场景只是简单的对Future接口和Callable接口进行使用介绍，注意Future接口的get()方法会阻塞，直到线程池中的线程将数据处理完成，才执行后面的操作。

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class FutrueTest
{

	public static void main(String[] args) throws Exception
	{

		ExecutorService executor = Executors.newSingleThreadExecutor();// 单线程，线程池
		Future<Long> myFuturetask = executor.submit(new MyFutureTask());// 提交任务
		System.out.println("get before");
		long result = myFuturetask.get();// 这个地方会阻塞
		System.out.println("get after");
		System.out.println("get result is " + result);
	}
}

class MyFutureTask implements Callable<Long>
{

	[@Override](https://my.oschina.net/u/1162528)
	public Long call() throws Exception
	{
		long result = 1;

		System.out.println("future task start");

		long max = new Random().nextInt(10);

		for (int i = 1; i <= max; i++)//计算阶乘
		{
			result *= i;
		}
		TimeUnit.SECONDS.sleep(10);
		System.out.println("future task end");
		return result;
	}
}

执行结果

get before
future task start
future task end
get after
get result is 720

场景二

现在有这样一个需求，就是一下子提交很多的FutureTask到线程池中，然后我等待处理的结果，此时我要做的是：哪个FutureTask先处理完成，我就先处理其得到的结果。问题的难度在于：每个提交到线程池中的FutureTask处理的时间都是不一样的，我怎么来的得知那个FutureTask线程先处理完呢？ 题外话：仔细想想：用Join()、CountDownLatch类、CyclicBarrier类是不是感觉都不太好实现？考虑了一下直接Runnable接口实现呢,是不是也会很麻烦？！后续会给出对比~ 废话不多说，直接上代码：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class FutrueTest
{

	public static void main(String[] args) throws Exception
	{

		ExecutorService executor = Executors.newCachedThreadPool();// 多个线程的线程池
		List<Future<MyResult>> list = new ArrayList<Future<MyResult>>();
		for (int i = 1; i <= 6; i++)
		{
			list.add(executor.submit(new MyFutureTask(String.valueOf(i))));//提交任务
		}

		System.out.println("do your something");
		TimeUnit.SECONDS.sleep(3);

		int rank = 1;
		while (true)//一直访问，直到task 列表中的task 为零
		{
			if (list.size() <= 0)
			{
				break;
			}
			Iterator<Future<MyResult>> iterator = list.iterator();
			while (iterator.hasNext())//循环访问task
			{
				Future<MyResult> f = iterator.next();
				if (f.isDone())//task 是否完成，如果完成则获取值，如果
				{
					MyResult result = f.get();
					System.out.println("------------------>my rank is " + rank++ + " future task is " + result.name
							+ " result is " + result.result);
					iterator.remove();
				}
			}
		}
	}
}

class MyFutureTask implements Callable<MyResult>
{

	private String name;

	public MyFutureTask(String name)
	{
		this.name = name;
	}

	[@Override](https://my.oschina.net/u/1162528)
	public MyResult call() throws Exception
	{
		long result = 1;

		long max = new Random().nextInt(10);

		for (int i = 1; i <= max; i++)// 计算阶乘
		{
			result *= i;
		}
		TimeUnit.SECONDS.sleep(new Random().nextInt(10));
		System.out.println(name + " future task result " + result);

		return new MyResult(name, result);
	}
}

class MyResult
{
	String name;//记录任务ID
	long result;//结果

	public MyResult(String name, long result)
	{
		super();
		this.name = name;
		this.result = result;
	}

}

运行结果：

do your something
6 future task result 1
5 future task result 6
------------------>my rank is 1future task is 5 result is 6
------------------>my rank is 2future task is 6 result is 1
2 future task result 40320
------------------>my rank is 3future task is 2 result is 40320
1 future task result 6
4 future task result 720
------------------>my rank is 4future task is 1 result is 6
------------------>my rank is 5future task is 4 result is 720
3 future task result 24
------------------>my rank is 6future task is 3 result is 24

这个地方主要注意这个isDown()这个函数来判断提交的Future任务是否执行完成，如果完成就获取任务结果做后续的处理。 但是我们发现，存在一个问题就是：并没有真的像我想想的那样，哪个任务先执行完，我就先处理哪个，难道就真的没有办法了么？！ 看下面代码:


import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class FutrueTest
{

	public static void main(String[] args) throws Exception
	{

		ExecutorService executor = Executors.newCachedThreadPool();// 多个线程的线程池
		CompletionService<MyResult> completionService = new ExecutorCompletionService<MyResult>(executor);//主要是这个类

		for (int i = 1; i <= 6; i++)
		{
			completionService.submit(new MyFutureTask(String.valueOf(i)));// 提交任务
		}
		System.out.println("do your something");
		TimeUnit.SECONDS.sleep(3);//休眠，也可以不休眠
		int rank = 0;
		for (int i = 1; i <= 6; i++)
		{

			MyResult result = completionService.take().get();// 会阻塞哦

			System.out.println("------------------>my rank is " + rank++ + " future task is " + result.name
					+ " result is " + result.result);
		}

	}
}

class MyFutureTask implements Callable<MyResult>
{

	private String name;

	public MyFutureTask(String name)
	{
		this.name = name;
	}

	[@Override](https://my.oschina.net/u/1162528)
	public MyResult call() throws Exception
	{
		long result = 1;

		long max = new Random().nextInt(10);

		for (int i = 1; i <= max; i++)// 计算阶乘
		{
			result *= i;
		}
		TimeUnit.SECONDS.sleep(new Random().nextInt(10));
		System.out.println(name + " future task result " + result);

		return new MyResult(name, result);
	}
}

class MyResult
{
	String name;// 记录任务ID
	long result;// 结果

	public MyResult(String name, long result)
	{
		super();
		this.name = name;
		this.result = result;
	}

}

运行结果

do your something
3 future task result 24
1 future task result 6
4 future task result 1
------------------>my rank is 0 future task is 3 result is 24
------------------>my rank is 1 future task is 1 result is 6
------------------>my rank is 2 future task is 4 result is 1
5 future task result 720
6 future task result 40320
------------------>my rank is 3 future task is 5 result is 720
------------------>my rank is 4 future task is 6 result is 40320
2 future task result 2
------------------>my rank is 5 future task is 2 result is 2

终于得到了我们想要的结果。

总结 Callable接口和Runnable接口在某些情况下都可以提交一个自己的任务给线程池来执行。

区别在于：

1.Callable接口可以有返回值，而Runnable接口没有。（当然不是绝对的看你怎么实现）

2.Callable接口实现对象通过ExecutorService接口的submit()方法提交到线程池，而Runnable接口实现对象通过Executor接口的execute()方法提交大线程池，当然ExecutorService接口继承Executor接口

至于他们的使用，看场景

转载于:https://my.oschina.net/u/1473861/blog/1607462

Java Future接口、Future模式理解
专注基础架构领域
12-16 1213
而在服务端程序，阻塞操作会降低系统的吞吐量，future模式试用的范围较窄，一般服务端采用异步回调的方式，将耗时的操作并行化，再通过回调方式将结果合并。Future构造时生成了虚拟的结果，如果使用这个结果越晚，当get_result时越不容易阻塞，所以从生成future到获取结果的间隔越长，future模式的功效越大。什么是future：future的原理是当你申请资源（计算资源或I/O资源）时，立即返回一个虚拟的资源句柄，当真正使用的时候，再将虚拟的句柄转化成真正的资源，相当于预获取。
java面试--Future,FutureTask,Callable,Runnable关系
软件工程
09-27 582
草稿
JAVA中的多线程之Thread，Runnable和Callable<V>
weixin_43938560的博客
04-30 874
JAVA中线程的实现 线程的实现主要通过三种方式 1. 通过继承Thread类 一个类只要继承了Thread类，那么这个类就可以称之为多线程类，在Thread的子类中必须明确的覆写Thread类的run()方法，此方法称之为线程主体。 但是要启动线程并不能直接调用run()方法，而是要调用从Thread类中继承来的start()方法来启动线程。 在使用了线程后，哪一个线程对象先抢到了CPU资源，哪...
Future<V>的使用
weixin_40626699的博客
03-25 4143
1、定义 Future是JAVA并发框架Executor中的一个类，Executor就是Runnable和Callable的调度容器，Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作，用get()可以获得执行结果。 2、举例 public class FutureTask(){ private static Executo...
java future_JAVA Future类详解
weixin_34410564的博客
02-12 475
1. Future的应用场景在并发编程中，我们经常用到非阻塞的模型，在之前的多线程的三种实现中，不管是继承thread类还是实现runnable接口，都无法保证获取到之前的执行结果。通过实现Callback接口，并用Future可以来接收多线程的执行结果。Future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。举个例子：比如...
java future<v>_java并发编程学习2--Future
weixin_39646688的博客
03-04 202
【Future的概念interface Future ，表示异步计算的结果，Future有个get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。相对于继承Thread来创建线程方式，使用Runnable可以让你的实现类同时实现多个接口，而相对于Callable及Future，Runnable方法并不返回任务执行结果且不能抛出异常。【interf...
【JDK1.8】Future<V>
码农笔记
12-03 544
一、方法如下： 二、方法解释 boolean cancel(boolean mayInterruptIfRunning); 1、试图取消此任务的执行，如果这个任务已经完成、已经被取消或者由于其他原因导致该任务不能取消，会执行失败（返回false）。如果任务已经 2、被成功取消，没有开始执行的任务不再被执行。如果这个任务已经开始，然后参数 mayInterruptIfRu...
Java：Runnable和Callable＜V＞以及FutureTask
東辰的博客
04-23 389
一、两者的使用区别 Runnable 实现Runnable的run方法，无返回值，无法抛出异常 class RunnableTest implements Runnable { @Override public void run() { System.out.println("我是Runnable"); } } 使用 直接通过线程来调用 Thread thread = new Thread(new RunnableTest(), "线程"); thread.star
《Java源码分析》：Future、RunnableFuture、FutureTask
wojiushimogui的博客
08-06 4873
《Java源码分析》：线程池 Future、RunnableFuture、FutureTask在使用ThreadPoolExecutor使用submit提交任务后然后交给线程池中的线程去执行，是吧在ThreadPoolExecutor(其实是在AbstractExecutorService中)有如下几个submit方法， public Future<?> submit(Runnable ta
Future接口介绍
移动互联网开发者
12-15 1072
在Java中，如果需要设定代码执行的最长时间，即超时，可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分，在java.util.concurrent包中。Future接口是Java线程Future模式的实 现，可以来进行异步计算。 Future模式可以这样来描述：我有一个任务，提交给了Future，Future替我完成这个
java.util.concurrent.Callable<V>
poijm
03-08 1007
java.util.concurrent Interface Callable Type Parameters:V - the result type of method call All Known Subinterfaces:JavaCompiler.CompilationTask public interface Callable A tas
java Future 接口介绍
nicknailo博客
03-25 360
在Java中，如果需要设定代码执行的最长时间，即超时，可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分，在java.util.concurrent包中。Future接口是Java线程Future模式的实现，可以来进行异步计算。 Future模式可以这样来描述：我有一个任务，提交给了Future，Future替我完成
Callable<V>、Future<V>详解 | Executor框架
u011007180的博客
11-29 971
一：关于 Callable的源码 Java代码   package java.util.concurrent;    public interface Callable {      /**      * Computes a result, or throws an exception if unable to do so.      *      * @return
Callable接口详解
逍遥绝情的博客
02-26 2万+
Callable接口详解 Callable: 返回结果并且可能抛出异常的任务。 优点： 可以获得任务执行返回值； 通过与Future的结合，可以实现利用Future来跟踪异步计算的结果。 Runnable和Callable的区别： 1、Callable规定的方法是call(),Runnable规定的方法是run(). 2、Callable的任务执行后可返回值，而Runnable的任务是...
线程池系列 之 Future＜V＞ 接口
一个搬砖工人
08-30 962
1继承关系图 2 Runnable接口 Runnable接口是线程辅助类，仅定义了一个方法run()方法。 灵活：Runnable可以继承其他类 实现对Runnable实现类的增强，避免了Thread类由于继承Thread类而无法继承其他类的问题。 共享资源：Runnable接口的run()方法可以被多个线程共享，适用于多个进程处理一种资源的问题。 Runnable或Thread的区别： （1）Runnable的实现方式是实现其接口即可 （2）Thread的实现方式是继承其类 （3）Runnable接
线程池， Callable<V>接口
weixin_34044273的博客
03-31 119
线程池： 概念：线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。 Executors：线程池创建工厂类 ExecutorService：线程池类 ExecutorService er=Executors.newFixedThreadPool(int);返回线程池对象 submit()获取线程池中的某一个线程对象...
public interface Future<V>Future 表示异步计算的结果
legend_x的专栏
02-20 1608
public interface FutureFuture 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。还提供了其他方法，以确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。如果为了可取消性而使用 Future 但又不提供
论多线程“分而治之“Future＜V＞的执行效率
热门推荐
吴名氏的博客
09-02 14万+
如果需要多个任务同时进行的,我们用什么方式最方便呢,第一种肯定是同步进行,一个一个进行,这样子肯定最慢的,还有一种就是同时进行,即:"分而治之",使用Future接口。
package ajiayou.index0711.demo03; import java.util.Random; import java.util.concurrent.Callable; public class Match2 implements Callable<Integer> { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public Integer call() throws Exception { Random r = new Random(); //这里是随机数 int speed = r.nextInt(100); int dist = 0; for(int i = 1; i<=100; i++) { //睡眠100毫秒 Thread.sleep(30); //Thread.currentThread().getName() //获得当前线程的名称 dist += i * speed; System.out.println(this.getName() + "已前进" + (dist) + "米(" + speed + "米/秒)"); } return dist; } } /* 注释补充：创建一个线程 Java 提供了三种创建线程的方法： 1.通过继承 Thread 类本身； 2.通过实现 Runnable 接口； 3.通过 Callable 和 Future 创建线程。 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。 */ package ajiayou.index0711.demo03; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class Test2 { public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService es = Executors.newFixedThreadPool(3); //创建了3个线程 Match2 m = new Match2(); m.setName("java"); Match2 m1 = new Match2(); m1.setName("mysql"); Match2 m2 = new Match2(); m2.setName("boot"); //开始对上面的线程进行执行 Future<Integer> future = es.submit(m); Future<Integer> future1 = es.submit(m1); Future<Integer> future2 = es.submit(m2); Integer i = future.get(); Integer i1 = future1.get(); Integer i2 = future2.get(); System.out.println(m.getName() + "共跑了" + i + "米"); System.out.println(m1.getName() + "共跑了" + i1 + "米"); System.out.println(m2.getName() + "共跑了" + i2 + "米"); } }
最新发布
07-15
使用FutureTask类来包装Callable对象，FutureTask实现了RunnableFuture接口，而RunnableFuture又继承了Runnable和Future接口。 3. 将FutureTask对象作为Thread的target创建线程并启动。 4. 调用FutureTask对象的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值