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

最新推荐文章于 2022-04-16 20:20:06 发布
最新推荐文章于 2022-04-16 20:20:06 发布
阅读量222 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/u/1473861/blog/1607462
版权

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

weixin_34204057
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Future<V>的使用
weixin_40626699的博客
03-25 4064
1、定义 Future是JAVA并发框架Executor中的一个类，Executor就是Runnable和Callable的调度容器，Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作，用get()可以获得执行结果。 2、举例 public class FutureTask(){ private static Executo...
java Future 接口使用方法详解
08-31
FutureTask<String> future = new FutureTask<>(new Callable<String>() { public String call() { // 实际任务代码 } }); executor.execute(future); try { result = future.get(5, TimeUnit.SECONDS); // 设置...
Callable<V>、Future<V>详解 | Executor框架
跑龙套@程序
09-29 270
  一：关于 Callable&lt;V&gt;的源码 package java.util.concurrent; public interface Callable&lt;V&gt; { /** * Computes a result, or throws an exception if unable to do so. * * @...
callable的使用方法详解
qq_49529172的博客
04-16 8587
1.callable的使用方法 2.为何能带有返回值？源码解析
线程池， Callable<V>接口
weixin_34044273的博客
03-31 88
线程池： 概念：线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。 Executors：线程池创建工厂类 ExecutorService：线程池类 ExecutorService er=Executors.newFixedThreadPool(int);返回线程池对象 submit()获取线程池中的某一个线程对象...
并发编程学习之Callable接口
weixiaohuai的博客
02-26 461
一、简介 Callable接口，其实跟Runnable接口的使用差不多，只不过Callable接口可以有返回值，返回结果并可能引发异常的任务。但是，Runnable不返回结果，也不能抛出checked异常。 二、源码 @FunctionalInterface public interface Callable<V> { /** * Computes a res...
Java多线程之Callable接口的实现
08-27
FutureTask<Integer> future = new FutureTask<Integer>(callable); new Thread(future).start(); try { Thread.sleep(5000); System.out.println(future.get()); } catch (InterruptedException e) { e....
Java多线程Callable接口实现代码示例
08-29
public interface Callable<V> { V call() throws Exception; } ``` 从 Callable 的定义可以看出，Callable 接口类似于 Runnable 接口，两者都是为那些其实例可能被另一个线程执行的类设计的。方法可以有返回值，...
Java多线程实现Callable接口
09-02
2. **Future接口**：`Future<List<Map<String, Object>>> future` 是一个Future对象，它是用于获取Callable线程执行结果的接口。`future.get()` 方法会阻塞，直到计算完成并返回结果。 3. **ExecutorService**：`...
浅谈在Java中使用Callable、Future进行并行编程
08-28
public interface Callable<V> { V call() throws Exception; } ``` 相比Runnable，Callable使得并行任务能返回计算结果，这对于需要处理计算结果的场景非常有用。 Future接口则用于管理Callable任务的执行状态和...
三种创建线程方式之Callable接口
lixinkuan的博客
07-03 921
一、类继承关系及API解析 Callable接口 @FunctionalInterface public interface Callable<V> { V call() throws Exception; } Callable接口中只有一个call()方法，和Runnable相比，该方法有返回值并允许抛出异常。 但是这里有一个问题，进程是要通过Thread类去创建...
详述Java实现Callable接口实现多线程的方式
weixin_42606135的博客
07-30 2万+
公司项目忙的晕头转向，终于有时间可以看点自己想看的东西了。在这里把最近学习的实现Callable接口实现多线程的方式做一个总结： 首先我们都知道，在Java中最常见的是继承Thread类和实现Runnable接口来实现多线程（ 这里我推荐采用实现接口的方式来实现多线程，原因有两点： 1、Java的设计是单继承的设计，如果采用继承Thread的方式实现多线程，则不能继承其他的类。 2、采用接...
Callable接口详解
逍遥绝情的博客
02-26 2万+
Callable接口详解 Callable: 返回结果并且可能抛出异常的任务。 优点： 可以获得任务执行返回值； 通过与Future的结合，可以实现利用Future来跟踪异步计算的结果。 Runnable和Callable的区别： 1、Callable规定的方法是call(),Runnable规定的方法是run(). 2、Callable的任务执行后可返回值，而Runnable的任务是...
深入理解Callable
xingfeng_coder的博客
08-22 2万+
概述Callable和Runnbale一样代表着任务，区别在于Callable有返回值并且可以抛出异常。其使用如下： public class CallableDemo { static class SumTask implements Callable<Long> { @Override public Long call() throws Exception
Java中的Runnable、Callable、Future、FutureTask的区别与示例
热门推荐
Mr.Simple的专栏
05-01 4万+
Java中的Runnable、Callable、Future、FutureTask的区别与示例
Runnable和Callable的区别和用法
刘运召的博客
11-11 1万+
创建线程的四种方式 Java多线程实现方式主要有四种：继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。
Callable与Future的介绍
weixin_30954265的博客
09-28 335
Callable与Future的介绍 Callable与 Future两功能是Java在后续版本中为了适应多并法才加入的，Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务。 Callable的接口定义如下； public interface Callable<V> { ...
【JDK1.8】Future<V>
码农笔记
12-03 446
一、方法如下： 二、方法解释 boolean cancel(boolean mayInterruptIfRunning); 1、试图取消此任务的执行，如果这个任务已经完成、已经被取消或者由于其他原因导致该任务不能取消，会执行失败（返回false）。如果任务已经 2、被成功取消，没有开始执行的任务不再被执行。如果这个任务已经开始，然后参数 mayInterruptIfRu...
java future<v>_java并发编程学习2--Future
weixin_39646688的博客
03-04 155
【Future的概念interface Future ，表示异步计算的结果，Future有个get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。相对于继承Thread来创建线程方式，使用Runnable可以让你的实现类同时实现多个接口，而相对于Callable及Future，Runnable方法并不返回任务执行结果且不能抛出异常。【interf...
Java多线程：JDK5.0的Callable接口与线程池
FutureTask<Integer> futureTask = new FutureTask<>(callable); Thread thread = new Thread(futureTask); thread.start(); try { Integer result = futureTask.get(); System.out.println("计算结果：" + ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值