简谈java并发FutureTask的实现

  • 更新时间:2022-07-12 08:47:21
  • 编辑:贺竹韵

概述

在使用java多线程解决问题的时候,为了提高效率,我们常常会异步处理一些计算任务并在最后异步的获取计算结果,这个过程的实现离不开Future接口及其实现类FutureTask。FutureTask类实现了Runnable, Future接口,接下来我会通过源码对该类的实现进行详解。

使用

我们先看下FutureTask中的主要方法如下,可以看出FutureTask实现了任务及异步结果的集合功能。看到这块的方法,大家肯定会有疑问,Runnable任务的run方法返回空,FutureTask如何依靠该方法获取线程异步执行结果,这个问题,我们在下面给大家介绍。

//以下五个方法实现接口Future中方法
public boolean isCancelled(); 
public boolean isDone(); 
public boolean cancel();
public V get() throws InterruptedException, ExecutionException;
public V get(long timeout, TimeUnit unit);
//实现接口Runnable中方法
public void run();

我们在使用中会构造一个FutureTask对象,然后将FutureTask扔到另一个线程中执行,而主线程继续执行其他业务逻辑,一段时间后主线程调用FutureTask的get方法获取执行结果。下面我们看一个简单的例子:

/**
* Created by yuanqiongqiong on 2019/4/9.
*/
public class FutureTaskTest {
private static ExecutorService executorService = Executors.newFixedThreadPool(1);
public static void main(String []args) {
Callable callable = new AccCallable(1, 2);
FutureTask futureTask = new FutureTask(callable);
executorService.execute(futureTask);
System.out.println("go to do other things in main thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("go back in main thread");
try {
int result = (int) futureTask.get();
System.out.println("result is " + result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
static class AccCallable implements Callable<Integer> {
private int a;
private int b;
public AccCallable(int a, int b) {
this.a = a;
this.b = b;
}
@Override
public Integer call() throws Exception {
System.out.println("acc a and b in threadId = " + Thread.currentThread().getName());
return a + b;
}
}
}

输出结果为:

go to do other things in main thread
acc a and b in threadId = pool-1-thread-1
go back in main thread
result is 3

实现分析

在分析实现前,我们先想下如果让我们实现一个类似FutureTask的功能,我们会如何做?因为需要获取执行结果,需要一个Object对象来存执行结果。任务执行时间不可控性,我们需要一个变量表示执行状态。其他线程会调用get方法获取结果,在没达到超时的时候需要将线程阻塞或挂起。

因此需要一个队列类似的结构存储等待该结果的线程信息,这样在任务执行线程完成后就可以唤醒这些阻塞或挂起的线程,得到结果。FutureTask的实际实现也是类似的逻辑,具体如下。

首先看下FutureTask的主要成员变量如下:

//futureTask执行状态
private volatile int state;
//具体的执行任务,会在run方法中抵用callable.call()
private Callable<V> callable;
//执行结果
private Object outcome; 
//获取结果的等待线程节点
private volatile WaitNode waiters;

对于执行状态,在源码中已经有了非常清晰的解释,这里我只是贴出源码,不在进行说明,具体如下:

/**
* Possible state transitions:
* NEW -> COMPLETING -> NORMAL
* NEW -> COMPLETING -> EXCEPTIONAL
* NEW -> CANCELLED
* NEW -> INTERRUPTING -> INTERRUPTED
*/
private static final int NEW = 0;
private static final int COMPLETING = 1;
private static final int NORMAL = 2;
private static final int EXCEPTIONAL = 3;
private static final int CANCELLED = 4;
private static final int INTERRUPTING = 5;
private static final int INTERRUPTED = 6;

然后我们看下FutureTask的构造函数,如下:

public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
//构造函数传入runnable对象时调用静态工具类Executors的方法转换为一个callable对象
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}

如前所述,FutureTask的执行线程中会调用其run()方法执行任务,我们看下这块逻辑:

public void run() {
//1.如果执行状态不是NEW或者有其他线程执行该任务,直接返回
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
//2.如果执行状态是NEW,即任务还没执行,直接调用callable.call()方法获取执行结果
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
//3.发生异常,更新status为EXCEPTIONAL,唤醒挂起线程
setException(ex);
}
//4.如果结果成功返回,调用set方法将设置outcome,更改status执行状态,唤醒挂起线程
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}

我们看下set函数的实现,具体看下4中的执行:

protected void set(V v) {
//将执行状态变更为COMPLETING
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
//设置执行结果
outcome = v;
//设置执行状态为NORMAL
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
//执行完成后处理操作,具体就是遍历阻塞链表,删除链表节点,并唤醒每个节点关联的线程
finishCompletion();
}
}

以上就是任务执行线程做的逻辑,以上逻辑也回答了FutureTask如何得到执行结果的疑问。下面我们看下用户调用get方法获取执行结果时的实现逻辑,这个时候FutureTask可能处理各种状态,即可能没有执行,执行中,已完成,发生异常等,具体如下:

public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if (unit == null)
throw new NullPointerException();
int s = state;
//执行状态是NEW或者COMPLETING时执行awaitDone将线程加入等待队列中并挂起线程
if (s <= COMPLETING &&
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
//根据执行状态status进行结果封装
return report(s);
}
//我理解这块是get的核心逻辑
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
//如果设置了超时时间,计算还有多长时间超时
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
//如果当前线程被中断,删除等待队列中的节点,并抛出异常
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
//如果执行状态已经完成或者发生异常,直接跳出自旋返回
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
//如果执行状态是正在执行,说明线程已经被加入到等待队列中,放弃cpu进入下次循环(真正的自旋)
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
//第一次进入循环,创建节点
else if (q == null)
q = new WaitNode();
//将节点加入到等待队列中,waiters相当于头阶段,不断将头结点更新为新节点
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) {
//如果设置了超时时间,在进行下次循环前查看是否已经超时,如果超时删除该节点进行返回
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
//挂起当前节点
LockSupport.parkNanos(this, nanos);
}
else
LockSupport.park(this);
}
}

这里需要说明一点,FutureTask中的阻塞队列新加入的节点都在头结点并且next指向之前的头结点,waitars指针总是指向新加入节点,通过waitars可以遍历整个等待队列,具体截图如下。此外等待队列节点结构很简单成员变量只有线程引用和next指针,这里再列出器接口。

简谈java并发FutureTask的实现

futureTask等待队列

读到这里,相信大家已经对FutureTask的实现细节有了一定的认识。此外,FutureTask没有使用锁而是使用Unsafe的是CAS的原子操作来解决竞争问题,减少了锁带来的上下文切换的开销,提高了效率。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

相关教程

  • Java用POI解析excel并获取所有单元格数据的方法整理

    下面小编就为大家带来一篇Java用POI解析excel并获取所有单元格数据的实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧

    发布时间:2019-08-29

  • java中jvm虚拟机栈的作用总结

    这篇文章主要介绍了jvm虚拟机栈的作用,本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下

    发布时间:2019-09-25

  • java实现udp通讯的实例讲解

    这篇文章主要为大家详细介绍了java实现udp通讯的代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

    发布时间:2019-06-09

  • Java中反射机制的知识点讲解

    反射(Reflection)是Java 程序开发语言的特征之一,它允许运行中的 Java 程序获取自身的信息,并且可以操作类或对象的内部属性,下面这篇文章主要给大家介绍了关于Java中反射机制的相关资料,需

    发布时间:2020-06-08

  • JavaWeb乱码问题的解决方法

    这篇文章主要给大家介绍了关于JavaWeb乱码问题的终极解决方案,文中通过示例代码介绍的非常详细,对大家学习或者使用JavaWeb具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧

    发布时间:2019-07-29

  • 实例讲述Java使用正则表达式截取重复出现的XML字符串功能

    这篇文章主要介绍了Java使用正则表达式截取重复出现的XML字符串功能,涉及java针对xml字符串及指定格式字符串的正则匹配相关操作技巧,需要的朋友可以参考下

    发布时间:2020-03-12

  • Java项目安全处理方法

    给网友朋友们带来一篇关于Java的教程,这篇文章主要介绍了Java项目安全处理方法,URL中参数显示,sql拼接问题,需要的朋友可以参考下

    发布时间:2022-06-23

  • Java二叉树路径和代码示例

    这篇文章主要介绍了Java二叉树路径和代码示例,具有一定借鉴价值,需要的朋友可以参考下。

    发布时间:2022-04-21

用户留言