JAVA多线程系列之二：Callable、Future与FutureTask

最新推荐文章于 2021-10-23 17:18:17 发布

隐于尘埃

最新推荐文章于 2021-10-23 17:18:17 发布

阅读量145

点赞数

分类专栏： JAVA多线程文章标签：多线程 java 源码分析

本文链接：https://blog.csdn.net/qq_39902667/article/details/90140200

版权

JAVA多线程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

JAVA多线程系列之二：Callable、Future与FutureTask

1.Callable与Runnable
2.Future
3.FutureTask

java创建线程有2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。
但这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。
而如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。
所以自从Java 1.5开始，就提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。
今天我们就来讨论一下Callable、Future和FutureTask三个类的使用方法。

1.Callable与Runnable

先说一下java.lang.Runnable吧，它是一个接口，在它里面只声明了一个run()方法：

public interface Runnable {
    public abstract void run();
}

由于run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果。
而Thread类继承与Runnable接口，所以结果是一致的。
Callable位于java.util.concurrent包下，它也是一个接口，在它里面也只声明了一个方法，只不过这个方法叫做call()：

/**
 * 返回结果和可能抛出异常的任务
 * 该接口与Runnable很相似，因为它们都是为其实例可能由另一个线程执行的类而设计的
 * 然而，Runnable不能返回结果和抛出异常
 *
 * @param <V> 方法{call}的返回
 */
@FunctionalInterface
public interface Callable<V> {
	
	/**
	 * 计算结果，如果无法执行则抛出异常。
	 * @return
	 * @throws Exception
	 */
	V call() throws Exception;
}

可以看到，这是一个泛型接口，call()函数返回的类型就是传递进来的V类型。
那么怎么使用Callable呢？一般情况下是配合ExecutorService来使用的，在ExecutorService接口中声明了若干个submit方法的重载版本：

/**
	 * 提交value-returning任务以供执行并返回一个Future呈现有待结果的任务。
	 * Future.get() 方法在当前任务完成后会返回任务的结果
	 * @param task 要提交的任务
	 * @param <T> 返回结果的类型
	 * @return 表示未完成任务的Future
	 * @throws RejectedExecutionException 如果该任务不能被调度器调度
	 * @throws NullPointerException 任务为空的话
	 */
	<T> Future<T> submit(Callable<T> task);
	
	/**
	 * 提交value-returning任务以供执行并返回一个Future呈现有待结果的任务。
	 * @param task 要提交的任务
	 * @param result 返回的结果
	  * @return 表示未完成任务的Future
	 * @throws RejectedExecutionException 如果该任务不能被调度器调度
	 * @throws NullPointerException 任务为空的话
	 */
	<T> Future<T> submit(Callable<T> task,T result);
	
	/**
	 * 提交value-returning任务以供执行并返回一个Future呈现有待结果的任务。
	 * @param task 要提交的任务
	  * @return 表示未完成任务的Future
	 * @throws RejectedExecutionException 如果该任务不能被调度器调度
	 * @throws NullPointerException 任务为空的话
	 */
	Future<?> submit(Runnable task);

第一个submit方法里面的参数类型就是Callable。
暂时只需要知道Callable一般是和ExecutorService配合来使用的，具体的使用方法讲在后面讲述。
一般情况下我们使用第一个submit方法和第三个submit方法，第二个submit方法很少使用。

2.Future

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。
Future类位于java.util.concurrent包下，它是一个接口：

/**
 1. 该类代表一个同步计算的结果。方法被提供来确认计算是否完成，用来等待其计算，
 2. 和用来获得计算结果。
 3. 结果只能通过{get}方法获取当计算已经完成时
 */
public interface Future<V> {
	
	/**
	 * 尝试关闭正在执行的该任务。该尝试会失败当任务早已完成、早已取消或者因为一些
	 * 原因无法关闭时。
	 * 当成功取消，该任务应该不能运行
	 * 如果任务早已启动，mayInterruptIfRunning 参数决定执行此任务的线程是否
	 * 应该被中断
	 * 
	 * @param mayInterruptIfRunning ture-如果执行此任务的线程应该被中断
	 * 			否则，此任务被运行完成
	 * @return false-如果此任务不能被取消，特别是因为它早已完成
	 */
	boolean cancel(boolean mayInterruptIfRunning);
	
	/**
	 * 返回ture如果此任务在完成前被取消
	 * @return 返回ture如果此任务在完成前被取消
	 */
	boolean isCancelled();
	
	/**
	 * 返回ture如果此任务已经完成
	 * 完成任务的原因有很多，比如正常执行完、异常或者被取消，以上情况都会返回ture
	 * @return 返回ture如果此任务已经完成
	 */
	boolean isDone();
	
	/**
	 * 等待如果需要计算完成，然后检索其结果。
	 * 
	 * @return 计算完的结果
	 * @throws CancellationException 如果此计算被取消
	 * @throws InterruptedException 计算过程抛出异常
	 * @throws ExecutionException 如果此任务在等待过程中被中断
	 */
	V get() throws InterruptedException,ExecutionException;
	
	/**
	 * 等待如果需要，最多计算完成的给定时间，然后检索其结果。
	 * @param timeout 最大等待时间
	 * @param unit 超时单位的时间单位
	 * @return 计算完的结果
	 * @throws CancellationException 如果此计算被取消
	 * @throws InterruptedException 计算过程抛出异常
	 * @throws ExecutionException 如果此任务在等待过程中被中断
	 * @throws TimeoutException 如果超出等待时间
	 */
	V get(long timeout, TimeUnit unit)
		throws InterruptedException,ExecutionException,TimeoutException;
	
}

在Future接口中声明了5个方法，下面依次解释每个方法的作用：
4. cancel(boolean mayInterruptIfRunning)方法，用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
5. isCancelled()方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
6. isDone()方法表示任务是否已经完成，若任务完成，则返回true；完成任务的原因有很多，比如正常执行完、异常或者被取消，以上情况都会返回ture。
7. get()用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
8. get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。
也就是说Future提供了三种功能：

判断任务是否完成；
能够中断任务；
能够获取任务执行结果。
因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。

3.FutureTask

Future接口和实现Future接口的FutureTask类，代表异步计算的结果。

3.1 FutureTask 简介

FutureTask 除了实现 Future 接口外，还实现了 Runnable 接口。因此，FutureTask 可以交给 Executor 执行，也可以由线程直接执行（ FutureTask.run() ）。
先看 FutureTask 的源码方法：

/**
 * 一个可取消的异步计算类。
 * 该类提供对Future接口的基本实现，使用方法来启动和取消计算，查询计算是否
 * 完成，并检索计算结果。
 * 计算结果仅当任务完成后才能获取。使用{get}方法会被阻塞当任务还在计算时。
 * @since 1.5
 * @param <V> 返回结果的类型
 */
public class FutureTask<V> implements RunnableFuture<V>{

	public FutureTask(Callable<V> callable);

	public FutureTask(Runnable runnable,V result);

	private V report(int s) throws ExecutionException;

	public boolean isCancelled();

	public boolean isDone();

	public boolean cancel(boolean mayInterruptIfRunning);

	public V get() throws InterruptedException,ExecutionException;
	
	public V get(long timeout, TimeUnit unit);

	protected void set(V v);

	public void run();
	
	protected boolean runAndReset();

	private int awaitDone(boolean timed, long nanos);

	private void removeWaiter(WaitNode node);
}

我们看一下上一篇我们所描述的 FutureTask 的结构：
在这里插入图片描述

根据 FutureTask.run() 方法被执行的时机，FutureTask 可以处于下面3种状态。

未启动。FutureTask.run() 方法还没有被执行之前，FutureTask 处于未启动状态。即当创建一个 FutureTask，且没有执行 FutureTask.run() 方法之前，这个 FutureTask 处于未启动状态。
已启动。FutureTask.run() 被执行的过程中，FutureTask 处于已启动状态。
已完成。FutureTask.run() 方法执行完后正常结束，或被取消（FutureTask.cancel(…)）,或执行 FutureTask.run() 方法时抛出异常而异常结束，FutureTask 处于已完成状态。
下面图1是 FutureTask 的状态迁移的示意图。

当 FutureTask 处于未启动或者已启动状态时，执行 FutureTask.get() 方法将导致调用线程阻塞；当 FutureTask 处于已完成状态时，执行 FutureTask.get() 方法将导致调用线程立即返回结果或者抛出异常。
当 FutureTask 处于未启动状态时，执行 FutureTask.cancel() 方法将导致此任务永远不会被执行；当 FutureTask 处于已启动状态时，执行 FutureTask.cancel(true) 方法将已中断执行此任务线程的方式来试图停止任务；当 FutureTask 处于已启动状态时，执行 FutureTask.cancel(false) 方法将不会对正在执行此任务的线程产生影响（让正在执行的任务运行完成）；当 FutureTask 处于已完成状态时，执行 FutureTask.cancel() 方法将返回false。
下面图2是 get 方法和 cancel 方法的执行示意图。

3.2 FutureTask 的使用

可以把 FutureTask 交给 Executor 执行；也可以通过 ExecutorService.submit(…) 方法返回一个 FutureTask ，然后执行 FutureTask.get() 方法或 FutureTask.cancel() 方法。除此以外，还可以单独使用 FutureTask。
下面为使用实例。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;

public class FutureTaskTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ExecutorService executor = Executors.newCachedThreadPool();
		FutureTaskTest t = new FutureTaskTest(); 
		Task task = t.new Task();
		FutureTask<Integer> futureTask = new FutureTask(task);
		executor.submit(futureTask);
		executor.shutdown();
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		System.out.println("主线程在运行");
		
		try {
			System.out.println("运行结果"+futureTask.get());
		} catch (InterruptedException e) {
			// TODO: handle exception
			e.printStackTrace();
		} catch (ExecutionException e) {
            e.printStackTrace();
        }
		System.out.println("所有任务执行完毕");
	}
	
	public class Task implements Callable<Integer>{
		
		public Integer call() throws Exception {
			System.out.println(Thread.currentThread().getName()+"线程正在执行");
			int sum = 0;
			for(int i=0;i < 100; i++)
				sum += i;
			return sum;
		}
	}
}

结果为下图所示。
在这里插入图片描述

3.3 FutureTask 的实现

FutureTask 有两个很重要的属性分别是 state runner ，futureTask 之所以可以支持cancel操作就是因为这两个属性。
其中 state 为 volatile 类型的整型值：

参数	含义	值
NEW	新建	0
COMPLETING	执行中	1
NORMAL	正常	2
EXCEPTIONAL	异常	3
CANCELLED	取消	4
INTERRUPTING	中断中	5
INTERRUPTED	被中断	6

state 的状态变化可以有四种方式
NEW->COMPLETING->NORMAL 正常完成的流程
NEW->COMPLETING->EXCEPTIONAL 出现异常的流程
NEW->CANCELED 被取消
NEW->INTERRUNPING->INTERRRUNPTED 被中断

我们研究下 Task 的状态变化也就是一个任务的生命周期:
我们创建一个FutureTask 首先会调用构造方法:

	/**
	 * 创建一个FutureTask,在运行时，执行给定的Callable,安排{get}方法将在
	 * 成功时返回给定的结果
	 * @param runnable 运行的任务
	 * @param result 在成功时返回给定结果。
	 * 如果不需要返回结果，可以考虑result为null
	 * @throws NullPointerException 如果runnable为空
	 */
	public FutureTask(Runnable runnable,V result) {
		this.callable = Executors.callable(runnable, result);
		this.state = NEW;
	}

在我们构造 Task 的时候会把状态设置成 NEW 也就是所有状态变化路径的起始状态
我们创建完一个 Task 会提交给 Executes 来执行(当然我们也可以自己启动Thread来执行效果基本是一样，只是交给线程池执行Task可能会延迟执行）。
在之后的Task生命周期的变化主要取决于 run() 方法先被调用还是 cancel () 方法会被调用，这两个方法的执行顺序决定了 Task 的生命周期的四种走向
我们先分析 run() 方法先被调用的情况，为了能对 run() 方法能更加详细的理解我在 run() 方法中加了增加了些注释

	public void run() {
		/**
	    * 首先判断任务的状态。如果任务的状态不是new说明任务的状态已经改变
	    * （说明他已经走了4种可能变化的一种）如果状态是new就会把当前执行任务
	    * 的线程付给runner, 这里用的cmpandset如果runner不为空 说明已经有线程
	    * 在执行任务也会退出执行,如果状态是new并且runner为空并且把当前的线程
	    * 付给了runner那么就继续执行任务(runner state 都是 volatile类型的
	    * 变量是一个很轻量机的线程安全操作)引起state状态变化的原因 就是调用
	    * 了cancel 或是 run
	    **/
		if(state != NEW || !UNSAFE.compareAndSwapObject(this,
				runnerOffset, null, Thread.currentThread()))
			return;
		//开始执行
		try {
			Callable<V> c = callable;
			if(c != null && state == NEW) {
				V result;
				boolean ran;
				try {
					result = c.call();
					//如果没有意外发生就执行成功了
					ran = true;
				} catch (Throwable e) {
					// TODO: handle exception
					result = null;
					ran = false;
					//设置异常
					setException(e);
				}
				if(ran)
					//如果转型成功了 设置结果
					set(result);
			}
		} finally {
			// TODO: handle finally clause
			//runner必须为非null直到状态结算，以防止并发调用run（）
			runner = null;
			int s = state;
			if(s >= INTERRUPTING) {
				handlePossibleCancellationInterrupt(s);
			}
		}
	}

Task 执行后如果成功会调用 set() 方法,如果有异常会调用 setException() 方法。
我们看下 set() 方法：

	/**
	 * 将此future的结果设置为给定值，除非此future已设置或者以被取消。
	 * 在{run}方法成功完成计算后，该方法会在内部被调用
	 * @param v 结果值
	 */
	protected void set(V v) {
		if(UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
			outcome = v;
			//将任务设置成NORMAL
			UNSAFE.putOrderedInt(this, stateOffset, NORMAL);
			finishCompletion();
		}
	}

如果现在的状态是 NEW 就把状态设置成 COMPLETING 然后设置成 NORMAL。这个执行流程导致的状态变化就是
NEW->COMPLETING->NORMAL

执行步骤是首先执行 run() 并且 Task 正常完成而且在这其间没有调用cancel()

上边是任务正常执行完成的状态变化，我们在看下有异常的情况。有异常的话会调用 setException()方法:

	/**
	 * 使该future报告一个给定的ExecutionException异常,除非该future已设置
	 * 或者已被取消
	 * 在{run}方法成功完成计算后，该方法会在内部被调用
	 * @param t 失败的原因
	 */
	protected void setException(Throwable t) {
		//如果state是new 把state设置成 COMPLETING
		if(UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
			outcome = t;
			UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL);
			finishCompletion();
		}
	}

如果现在的状态是 NEW 就把状态设置成 COMPLETING 然后设置成 EXCEPTIONAL。这个执行流程导致的状态变化就是 NEW->COMPLETING->EXCEPTIONAL
执行步骤是首先执行 run() 并且Task抛出异常而且在这其间没有调用cancel()。

上文所分析的场景只是 run() 方法被调用了而在 run() 方法执行的过程中。调用 cancel() 并没有分析，两个方法有时间交集的情况我们稍后分析。
现在我们分析下 cancel() 方法先被调用的情况

	/**
	 *尝试关闭正在执行的该任务。该尝试会失败当任务早已完成、早已取消或者
	 * 因为一些原因无法关闭时。当成功取消，该任务应该不能运行如果任务早已
	 * 启动，mayInterruptIfRunning 参数决定执行此任务的线程是否应该被中断
	*/
	public boolean cancel(boolean mayInterruptIfRunning) {
		/*
		 * 如果state不是new 那么就退出方法，这时的任务是已经
		 * 完成了、或是被取消了、或是被中断了
		 */
		if(!(state == NEW && UNSAFE.compareAndSwapInt(this,stateOffset,
				NEW,mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
			return false;
		try {
			if(mayInterruptIfRunning) {
				try {
					//如果是可中断 那么就 调用系统中断方法 然后把状态设置成INTERRUPTED
					Thread t = runner;
					if(t != null) t.interrupt();
				} finally {
					// TODO: handle finally clause
					UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
				}
			}
		} finally {
			// TODO: handle finally clause
			finishCompletion();
		}
		return true;
	}

这个方法很简单：
1.如果是 cancel(false) 那么 Task 的状态变化就是
NEW->=CANCELLED
2.如果是 cancel(true)那么Task的状态化就是
NEW->INTERRUPTING ->INTERRUPTED

至此 Task 的四种状态变化我们都看到了，不过这都是在两个方法都是单独执行的情况。
我们在分析下两个方法交叉执行的情况( run()->cancel() )：

如果 Task 已经执行然后再调用 cancel():
A.调用 cancel(false)情况
a.如果Task已经在执行而 callable.call() 没有返回或是 call() 已经返回但是state状态还没有改变,那么任务调用cancel(false) 不会对任务的执行造成影响只会影响task的状态.
b.如果 callable.call() 已经返回并且状态已经变成 COMPLETING 或是 COMPLED 那么对任务执行和任务状态都没有影响.
B：调用 cancel(true)
a.如果任务已经在执行而 callable.call() 没有返回会把 state 设置成 INTERRUPTING 然后调用执行线程的中断请求,然后把状态设置成 INTERRUPTED,这里如果 callable.call() 方法可以响应中断可能对任务执行产生影响，如果方法不会响应中断不会对任务运行产生影响。
b.如果任务已经在执行并且 call() 已经返回但是 state 状态还没有改变 ,不会对任务的执行造成影响,只会影响任务的状态。
调用 cancel() 后在执行任务 ( cancel() -> run() )
先调用 cancel() 无论是那种调用方式都会引起state状态的变化。在 run() 方法执行的时候发现state 已经不是 new 了,就会放弃任务的执行

隐于尘埃

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA多线程系列之二：Callable、Future与FutureTask

JAVA多线程系列之二：Callable、Future与FutureTask1.Callable与Runnable2.Future3.FutureTask3.1 FutureTask 简介3.2 FutureTask 的使用3.3 FutureTask 的实现java创建线程有2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。但这2种方式都有一个缺陷就是：在执行完任务...
复制链接

扫一扫