Callable与FutureTask

最新推荐文章于 2022-05-12 16:46:52 发布
最新推荐文章于 2022-05-12 16:46:52 发布
阅读量184 收藏 1
点赞数
分类专栏： java 文章标签： java Callable FutureTask
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34785454/article/details/89070246
版权

FutureTask是《java并发编程实战》这本书里讲到的同步工具类的第二种。
提FutureTask之前，需要先提及Callable接口。
一般来讲，java中创建线程常用两种方式，一个是继承Thread类，一个是实现Runnable接口。第三种创建线程的方法就是实现Callable接口，实现接口中的call()方法。
通过callable创建的线程，是带有返回结果的，通过的就是FutureTask来拿到执行结果。并且call()方法可以抛出异常。这两点是Runnable接口所不具备的。用Thread及Runnable接口创建的线程，想拿到执行结果，需要线程通信或线程共享变量这些方式。

Callable与FutureTask用法如下：

public class FutureTest {

	public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
		InnerCall in = new InnerCall(3);
		FutureTask<Integer> f = new FutureTask<Integer>(in);
		Thread t1 = new Thread(f);
		t1.start();
		t1.join();
		System.out.println(f.get());
	}

}

class InnerCall implements Callable<Integer>{
	
	private int i;
	
	public InnerCall(int i) {
		this.i = i;
	}

	@Override
	public Integer call() throws Exception {
		int result = i;
		for(int j = 0 ; j < 10 ; j++)
			result = result * i;
		return result;
	}
	
}

运行结果如下：

177147

实现Callable接口需要通过泛型定义返回值的数据类型。在上面的代码中，模拟传入参数的十次方计算。通过创建FutureTask<Integer>对象，将Callable实例传入构造方法中，然后new Thread对象（构造参数为FutureTask实例）进行运行。调用FutureTask的get()方法来获得计算结果。

如果当前计算尚未结束，get()方法会阻塞，直到计算完毕才会返回结果或抛出异常：

public class FutureTest {

	public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
		InnerCall in = new InnerCall(3);
		FutureTask<Integer> f = new FutureTask<Integer>(in);
		Thread t1 = new Thread(f);
		t1.start();
		System.out.println("计算中......");
		System.out.println(f.get());
	}

}

class InnerCall implements Callable<Integer>{
	
	private int i;
	
	public InnerCall(int i) {
		this.i = i;
	}

	@Override
	public Integer call() throws Exception {
		Thread.sleep(4000);
		int result = i;
		for(int j = 0 ; j < 10 ; j++)
			result = result * i;
		return result;
	}
	
}

输出结果：

计算中......
177147

这段代码中，在call()方法第一步先让线程休眠了4秒。于是main方法运行后，马上输出了第一行计算中......，第二行则等待了几秒后才输出计算结果。这就是get()方法在计算结果出来之前会进行阻塞，直到计算完毕。

FutureTask常用方法：

public class FutureTest {

	public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
		InnerCall in = new InnerCall(3);
		FutureTask<Integer> f = new FutureTask<Integer>(in);
		Thread t1 = new Thread(f);
		t1.start();
		while(!f.isDone()) {
			System.out.println("没算完呢......");
		}
		System.out.println(f.get());
	}

}

class InnerCall implements Callable<Integer>{
	
	private int i;
	
	public InnerCall(int i) {
		this.i = i;
	}

	@Override
	public Integer call() throws Exception {
		Thread.sleep(4000);
		int result = i;
		for(int j = 0 ; j < 10 ; j++)
			result = result * i;
		return result;
	}
	
}

输出结果：

......
没算完呢......
没算完呢......
没算完呢......
没算完呢......
没算完呢......
177147

isDone()方法判断任务是否执行完成，上面这段代码中做了循环，如果任务没执行完则会一直复读机式地输出，直到执行完成，跳出循环计算结果。

cancel方法用来取消任务，如果任务取消后再调用get方法，则会抛出异常：

public class FutureTest {

	public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
		InnerCall in = new InnerCall(3);
		FutureTask<Integer> f = new FutureTask<Integer>(in);
		Thread t1 = new Thread(f);
		t1.start();
		f.cancel(true);
		System.out.println(f.get());
	}

}

class InnerCall implements Callable<Integer>{
	
	private int i;
	
	public InnerCall(int i) {
		this.i = i;
	}

	@Override
	public Integer call() throws Exception {
		Thread.sleep(4000);
		int result = i;
		for(int j = 0 ; j < 10 ; j++)
			result = result * i;
		return result;
	}
	
}

抛出异常：

Exception in thread "main" java.util.concurrent.CancellationException

cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。

get方法可以指定等待时间，如果超时了，也会直接抛出异常：

public class FutureTest {

	public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
		InnerCall in = new InnerCall(3);
		FutureTask<Integer> f = new FutureTask<Integer>(in);
		Thread t1 = new Thread(f);
		t1.start();
		System.out.println(f.get(1000,TimeUnit.MILLISECONDS));
	}

}

class InnerCall implements Callable<Integer>{
	
	private int i;
	
	public InnerCall(int i) {
		this.i = i;
	}

	@Override
	public Integer call() throws Exception {
		Thread.sleep(4000);
		int result = i;
		for(int j = 0 ; j < 10 ; j++)
			result = result * i;
		return result;
	}
	
}

上面这段代码，get方法指定等待时间一秒，下面的计算至少要4秒以上，于是main方法直接抛出异常：

Exception in thread "main" java.util.concurrent.TimeoutException

线程池中用到Callable和FutureTask比较多。此外《java并发编程实战》这本书里还举了两个例子。一个是通过FutureTask提前进行计算，然后在需要的时候直接通过get方法得到结果，提高效率。另外一个是将FutureTask任务缓存在ConcurrentHashMap当中，当有同样参数的运算进行时，可以直接在缓存中的FutureTask通过get方法获得计算结果。为什么缓存FutureTask任务而不缓存计算结果呢，书中讲的原因是有可能在两个参数相同的线程并发访问时，发现缓存都没有自己的结果，于是都进行了计算，这样效率低，所以改为了缓存任务。

参考：
https://www.cnblogs.com/fengsehng/p/6048609.html
感谢大佬带飞

qq_34785454
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程（二）：Callable和FutureTask结合使用获取返回值
qq_28834355的博客
11-05 1165
1. Callable 话不多说，直接上源码： @FunctionalInterface public interface Callable<V> { V call() throws Exception; } 跟上一篇讲的 Runnable 一样，Callable 也是一个函数式接口。此外，Callable 还是泛型类，可以指定 call 方法的返回值类型。 Callable 源码过于简单，看不出什么，下面我们再介绍一个类：FutureTask 2. FutureTask 2.1 F
Java[学习总结]-多线程（二）之Callable和FutureTask
qq_43502987的博客
12-18 621
1.使用意义 从JDK1.5之后，Java提供了Callable接口，实|际_上就是Runnable接口的增强版。提供call方 法作为线程执行体，但是功能更加强大。Call方法可以有返回值，Call方法可以抛出异常。 public interface Callable<V>{ V call() throws Exception; . } 2.使用Future （1）在并发编程时，一般使用runnable,然后给线程池，这种情况下不需要线程的结果。所以run（）的返回值是void类型。如果是一
JAVA多线程基础篇--Callable与FutureTask
qq_33479841的博客
01-20 2953
1.概述 2.实战演练 3.代码分析 4.小结 5.参考文献
Callable和Future、FutureTask的使用
陈守璐的专栏
07-29 341
在Java中，开启一个线程的唯一方式是，是通过Thread的start方法，并且在线程中执行的Runnable的run方法。无论是线程池还是接下来要介绍的Callable，Future还是线程池，最核心最根本的还是调用到Thread.start()–>Runnable.run()，其他的类的出现可以认为是更方便的使用Thread和Runnable，以此为核心会更容易理解Java的并发框架。
Java并发基础(17)：Callable、Future和FutureTask
mingyuli的博客
07-24 804
1、Callable<V>接口 我们先回顾一下java.lang.Runnable接口，就声明了run()其返回值为void，当然就无法获取结果 public interface Runnable { public abstract void run(); } 而Callable的接口定义如下 public interface Callable<V> { V call() throws Exception; } 该接口声明了一个...
Java随笔-Callable与FutureTask
qq_34202054的博客
03-25 228
通过Callable与FutureTask创建线程
Callable与Future
is_Javaer的博客
09-08 244
Runnable封装了一个异步运行的任务，只有一个没有参数和返回值的run方法，同时也不能抛出异常；Callable与其类似，只有一个call方法，但是它有参数和返回值，还能抛出异常，Callable可以看作是Runnable的加强版。 Runnable和Callable的定义如下： 从中可以看到： 1、 Callable能接受一个泛型，然后在call方法中返回一个这个类型的值，例如Calla...
Callable和FutureTask的关系(多线程篇)
m0_46741750的博客
01-05 511
01.我的Git总结 为什么学Callable 首先，我们今天要讲的就是线程，在线程中呢，我们创建一个线程，很简单，无非就是创建一个new Thread(),然后进行相应的做法。 Thread thread=new Thread(new Runnable() { @Override public void run() { System.out.println("这是一个线程"); } })
java多线程返回值使用示例(callable与futuretask)
09-04
为了解决这个问题，Java提供了`Callable`接口和`FutureTask`类，它们是实现多线程返回值的关键工具。 `Callable`接口类似于`Runnable`，但比它功能更强大。`Callable`接口中的`call()`方法可以返回一个结果，并且...
使用Callable和FutureTask创建线程的具体步骤
m0_38009788的博客
05-12 829
高并发Callable创建线程
Callable、Future和FutureTask解析
dark
04-29 639
引用自：http://www.importnew.com/17572.html java创建线程有两种方式： 一种是直接继承Thread 另外一种就是实现Runnable接口。 这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。 如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。 而自从Java 1.5开始，就提供了Calla...
并发编程之Callable、Future和FutureTask
博客
06-21 405
1
Callable、Future和FutureTask
深入Java世界：探索编程之美与技术深度
03-16 184
Runnable 是一个接口，在它里面只声明了一个 run()方法，由于 run()方法返 回值为 void 类型，所以在执行完任务之后无法返回任何结果。 Callable 位于 java.util.concurrent 包下，它也是一个接口，在它里面也只声明 了一个方法，只不过这个方法叫做 call()，这是一个泛型接口，call()函数返回的 类型就是传递进来的 V 类型。 Futu...
Callable、Future与FutureTask
文章中资料均可获取，有需要请添加yunduoa2019即可
09-26 382
通常来说，我们使用Runnable和Thread来创建一个新的线程。 但是它们有一个弊端，就是run方法是没有返回值的。而有时候我们希望开启一个线程去执行一个任务,并且这个任务执行完成后有一个返回值。 JDK提供了Callable 接口与Future 类为我们解决这个问题，这也是所谓的“异步"模型。 Callable接口 Callable与Runnable类似，同样是只有一个抽象方法的函数式接口。不同的是，Callable提供的方法是有返回值的，而且支持泛型。 那一般是怎么使用Callab.
Callable和FutureTask分析
nmgyangguangyuan的博客
06-24 288
文章目录Callable和FutureTask分析解决问题优势劣势应用场景组成部分FutureTask使用底层原理相似对比 Callable和FutureTask分析 解决问题 问题 ​ 创建线程的2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口,这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。 ​ 如果需要获取执行结果，就必须通过共享变量或者使用线程通...
Callable与Future以及FutureTask
zhouweiIT的专栏
09-14 481
Callable与Future的介绍     Callable与 Future 两功能是Java在后续版本中为了适应多并法才加入的，Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务。 Callable的接口定义如下； public interface Callable {       
Callable和FutureTask的使用
a1105575699的博客
11-18 3076
1 Callable 接口 接口内部仅有一个call()方法，方法返回类型为接口泛型定义的类型。实现类重写内部方法后，通过Future接口的包装类进行包装，来实现Runable接口，从而能够开启新的线程。与Runable不同的是：Runable执行的run()方法返回值是void，如果在工作需要中需要通过分线程获取执行结果，Runable就不能满足需求了。Callable接口通过泛型能够控制call的返回类型，因此，需要有返回的时候通常使用Callable。 实现类如下图例：（如果cal..
Callable、Future和FutureTask (五)
qq_32445069的博客
08-05 368
Callable、Future和FutureTask 通常大家都知道创建线程的方式主要是继承Thread和实现Runable接口，下面为大家介绍第三种方式，实现Callable接口。Callable只能在ExecutorService的线程池中跑，并且有返回结果，也可以通过返回的Future对象查询执行状态（Future 本身也是一种设计模式，它是用来取得异步任务的结果）。 结构图 Futu...
java多线程编程之Callable、Future和FutureTask。
piaoslowly的专栏
06-05 489
平时在工作中一般用到的多线程为：一种是直接继承Thread，另外一种就是实现Runnable接口，但是在最近工作遇到一个问题，希望线程执行完后返回结果。哦哦，上面两种都不允许有返回值，悲剧了。 一、来源 而自从Java 1.5开始，开始提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。 二、简单对比Runnable与Callable 1.Runnable是在ja
Java线程深入：Callable与FutureTask，线程池解析
与Runnable接口不同，Callable的call()方法可以有返回值。要使用Callable，我们需要遵循以下步骤： 1. 创建一个实现Callable接口的类，并在call()方法中定义线程执行的具体逻辑和可能的返回值。 2. 创建Callable类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值