源码分析-FutureTask

2024-06-10 18:18
文章标签 分析 源码 futuretask

本文主要是介绍源码分析-FutureTask,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

基本原理

首先FutureTask早期使用AQS来实现。目前的版本(java 7)是将所有状态用一个volatile的int来保存。并且使用unsafe的cas来进行修改。当然如果使用一个Atomic类也可以。但是使用unsafe效率更高。

状态介绍

    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;

首先基本的状态定义如上,差不多从名字上就可以看出来意义。
首先初始状态是NEW。
只有在调用了set、setException、cancal方法之后才会变成terminal。
在完成的过程中,状态会变成COMPLETING(正在设置结果)或者INTERRUPTING(中断任务以尝试满足取消指令cancel(true))。
从这些中间状态到达最终状态的过程使用有序/懒惰写因为这些值是唯一的而且不会被修改。

可能存在的状态转换

NEW -> COMPLETING -> NORMAL
NEW -> COMPLETING -> EXCEPTIONAL
NEW -> CANCELLED
NEW -> INTERRUPTING -> INTERRUPTED

内部域

    private volatile int state;private Callable<V> callable;//底层的callable,会在运行后清理private Object outcome; // 计算的结果或者需要抛出的异常,不使用volatile,而是使用状态读写private volatile Thread runner;//运行callable的线程。在run()方法中使用cas设置private volatile WaitNode waiters;//等待节点的集合

意义都比较的明确。

WaitNode内部静态类

    static final class WaitNode {volatile Thread thread;volatile WaitNode next;WaitNode() { thread = Thread.currentThread(); }}

WaitNode比较简单就是一个单向链表。这里还想说一下。关于内部类的问题。之前我一直纠结何种情况下应该用内部类何种情况下应该用内部静态类。不过前段时间看到effectivejava中间有一段说的比较好。简单的说。应该优先使用内部静态类,因为这样更安全,而且也不会绑定外部类的实例。也就是说只要内部类没有必要访问外部类实例的内容就应该使用静态的类。具体的可以书上的内容。

主要方法

构造器

首先构造器没什么好说的,就是设置以下callable和state。这里有一个包装的方法,可以将runnable和result包装成callable。

this.callable = Executors.callable(runnable, result);

get()方法

    public V get() throws InterruptedException, ExecutionException {int s = state;if (s <= COMPLETING)//当前状态为COMPLETING以下的状态就运行awaitDone等待计算完成或者s = awaitDone(false, 0L);return report(s);}

其次这两个方法awaitDonereport还是要看一下:

awaitDone

    private int awaitDone(boolean timed, long nanos)throws InterruptedException {final long deadline = timed ? System.nanoTime() + nanos : 0L;//根据参数计算可能存在的延时,预留WaitNode引用和入列标志位。WaitNode q = null;boolean queued = false;for (;;) {if (Thread.interrupted()) {//如果执行任务的线程中断了则需要移除Waiter并且抛出中断异常。removeWaiter(q);throw new InterruptedException();}int s = state;if (s > COMPLETING) {//状态大于COMPLETING则说明任务完成或中断则返回状态,还需要注意将WaitNode的可能存在的thread置为null以防止可能存在的意外操作。if (q != null)q.thread = null;return s;}else if (s == COMPLETING) // cannot time out yet//正在运行期间则等待。Thread.yield()为了避免过度的自旋。Thread.yield();else if (q == null)//设置新的WaitNode()而不是在整个方法开始之前是为了防止计算提前结束。这样就不用构造可以直接返回了。运行到这里说明之前已经让渡了,但是依然未完成所以需要准备入列。q = new WaitNode();else if (!queued)//使用cas去设置waitersOffsetqueued = 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);}elseLockSupport.park(this);}}

removeWaitNode
这上面有一个removeWaitNode方法
这里也用到了java版本的goto语句。语义标签。配合循环使用。
这里需要注意这个removeWaitNode是用来删除超时或者被中断你的节点的。这里使用了便利的操作,如果节点非常多的话这里会

    private void removeWaiter(WaitNode node) {if (node != null) {node.thread = null;retry:for (;;) {//第一个for循环其实没什么意义,这里只是为了使用retry:标签而使用的。为的是当出现重试的情况的时候goto到这里重试。for (WaitNode pred = null, q = waiters, s; q != null; q = s) {//第二个循环才是正体。s = q.next;if (q.thread != null)pred = q;else if (pred != null) {pred.next = s;if (pred.thread == null) // check for racecontinue retry;}else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,q, s))continue retry;}break;}}}

第二个循环体到底干了什么。这里看简单分析下。
pred记录的实际上是上一个thread不为null的有效节点,q是指向当前节点的指针,循环会从头到尾的遍历节点直到节点末尾。s是q的后继可能是节点可能是null。

从当前节点来看只有两种情况一种是当前节点q的thread为null,也就是说当前节点无效,这时候如果存在pred节点就使得pred的next为s也就是跳过当前节点。进入下一个循环(这里实际上还进行了竞争的判断就是确保pred的thread不为null。如果不满足条件则需要重头节点重新开始,这当然是非常耗时的。所以这里实际上是假设节点不会太多而且竞争不会太激烈,这个在源码中有介绍。)当然如果pred为null就说明在当前节点之前都没有有效的节点,则需要设置waitersOffset为当前的s。如果失败则重头开始。

当前节点q的thread如果不为null则尝试设置pred为当前节点,进入下一个循环。

removeWaiter的工作实际上就是将所有thread为null的节点全部扔掉。

report
此外还有一个report方法。这个就很简单了就是根据当前状态返回结果或者抛出异常。

    private V report(int s) throws ExecutionException {Object x = outcome;if (s == NORMAL)return (V)x;if (s >= CANCELLED)throw new CancellationException();throw new ExecutionException((Throwable)x);}

其实这里有一个我觉得略微有些可以讨论的问题。就是为什么把抛出的异常放到outcome中。我觉得完全可以新定义一个域比较合适。。

run()

    public void run() {if (state != NEW ||//这判断是为了防止并发错误。状态不为new说明已经启动了。当前线程设置失败说明已经有有线程开始执行这个任务了。!UNSAFE.compareAndSwapObject(this, runnerOffset,null, Thread.currentThread()))return;try {Callable<V> c = callable;if (c != null && state == NEW) {V result;boolean ran;//ran作为运行完成的标志,根据这个决定是调用set还是setException。try {result = c.call();//在当前线程中调用c.call();ran = true;} catch (Throwable ex) {result = null;ran = false;setException(ex);}if (ran)set(result);}} finally {// runner must be non-null until state is settled to// prevent concurrent calls to run()runner = null;//runner必须设置用来保证不会并发的调用run。// state must be re-read after nulling runner to prevent// leaked interruptsint s = state;if (s >= INTERRUPTING)//在设置runner为null之后重读state防止遗漏中断。handlePossibleCancellationInterrupt(s);}}

run方法比较简单。这里还是看一下set、setException和handlePossibleCancellationInterrupt几个方法:

set

    protected void set(V v) {if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {outcome = v;UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final statefinishCompletion();}}

CAS设置state成功后设置输出,然后在CAS设置为正常终止状态NORMAL。

finishCompletion
这个方法主要用来唤醒所有的等待线程。
这个方法比removeWaitNode要简单的多就是把所有有效的节点全部解锁。

    private void finishCompletion() {// assert state > COMPLETING;for (WaitNode q; (q = waiters) != null;) {if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {for (;;) {Thread t = q.thread;if (t != null) {q.thread = null;LockSupport.unpark(t);}WaitNode next = q.next;if (next == null)break;q.next = null; // unlink to help gcq = next;}break;}}done();//一个hook方法。callable = null;        // to reduce footprint}

handlePossibleCancellationInterrupt

这个方法比较有意思。只有在调用了cancel(true)的时候才会调用这个方法。这个方法是为了配合cancel使用的。

    private void handlePossibleCancellationInterrupt(int s) {if (s == INTERRUPTING)//如果状态为INTERRUPTING说明调用了cancel并且成功取消。这时候会有一个另一个线程尝试终止当前的线程。但是我们知道在java中中断不是立刻有效的,所以调用Thread.yield()来尝试让当前线程让步。直到取消当前线程的任务为INTERRUPTED程序才会继续往下跑。while (state == INTERRUPTING)Thread.yield(); // wait out pending interrupt}

setException
和set一样只不过是将状态设置为Exception。

cancel

    public boolean cancel(boolean mayInterruptIfRunning) {if (state != NEW)//任务一旦开始就没办法取消。return false;if (mayInterruptIfRunning) {if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, INTERRUPTING))//尝试设置当前状态为尝试中断。return false;Thread t = runner;if (t != null)//如果已经设置了线程则尝试中断他。t.interrupt();UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); //此状态为最终状态。}else if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, CANCELLED))//如果输入参数为false则说明不需要中断状态,而直接尝试进入取消状态。return false;finishCompletion();return true;}

这篇关于源码分析-FutureTask的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!


原文地址:
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.chinasem.cn/article/1048910

相关文章

Apache 高级配置实战之从连接保持到日志分析的完整指南

《Apache高级配置实战之从连接保持到日志分析的完整指南》本文带你从连接保持优化开始,一路走到访问控制和日志管理,最后用AWStats来分析网站数据,对Apache配置日志分析相关知识感兴趣的朋友... 目录Apache 高级配置实战:从连接保持到日志分析的完整指南前言 一、Apache 连接保持 - 性

Linux中的more 和 less区别对比分析

《Linux中的more和less区别对比分析》在Linux/Unix系统中,more和less都是用于分页查看文本文件的命令,但less是more的增强版,功能更强大,:本文主要介绍Linu... 目录1. 基础功能对比2. 常用操作对比less 的操作3. 实际使用示例4. 为什么推荐 less?5.

spring-gateway filters添加自定义过滤器实现流程分析(可插拔)

《spring-gatewayfilters添加自定义过滤器实现流程分析(可插拔)》:本文主要介绍spring-gatewayfilters添加自定义过滤器实现流程分析(可插拔),本文通过实例图... 目录需求背景需求拆解设计流程及作用域逻辑处理代码逻辑需求背景公司要求,通过公司网络代理访问的请求需要做请

Java集成Onlyoffice的示例代码及场景分析

《Java集成Onlyoffice的示例代码及场景分析》:本文主要介绍Java集成Onlyoffice的示例代码及场景分析,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要... 需求场景:实现文档的在线编辑,团队协作总结:两个接口 + 前端页面 + 配置项接口1:一个接口,将o

IDEA下"File is read-only"可能原因分析及"找不到或无法加载主类"的问题

《IDEA下Fileisread-only可能原因分析及找不到或无法加载主类的问题》:本文主要介绍IDEA下Fileisread-only可能原因分析及找不到或无法加载主类的问题,具有很好的参... 目录1.File is read-only”可能原因2.“找不到或无法加载主类”问题的解决总结1.File

8种快速易用的Python Matplotlib数据可视化方法汇总(附源码)

《8种快速易用的PythonMatplotlib数据可视化方法汇总(附源码)》你是否曾经面对一堆复杂的数据,却不知道如何让它们变得直观易懂?别慌,Python的Matplotlib库是你数据可视化的... 目录引言1. 折线图(Line Plot)——趋势分析2. 柱状图(Bar Chart)——对比分析3

Dubbo之SPI机制的实现原理和优势分析

《Dubbo之SPI机制的实现原理和优势分析》:本文主要介绍Dubbo之SPI机制的实现原理和优势,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录Dubbo中SPI机制的实现原理和优势JDK 中的 SPI 机制解析Dubbo 中的 SPI 机制解析总结Dubbo中

C#继承之里氏替换原则分析

《C#继承之里氏替换原则分析》:本文主要介绍C#继承之里氏替换原则,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录C#里氏替换原则一.概念二.语法表现三.类型检查与转换总结C#里氏替换原则一.概念里氏替换原则是面向对象设计的基本原则之一:核心思想:所有引py

基于Go语言实现Base62编码的三种方式以及对比分析

《基于Go语言实现Base62编码的三种方式以及对比分析》Base62编码是一种在字符编码中使用62个字符的编码方式,在计算机科学中,,Go语言是一种静态类型、编译型语言,它由Google开发并开源,... 目录一、标准库现状与解决方案1. 标准库对比表2. 解决方案完整实现代码(含边界处理)二、关键实现细

PostgreSQL 序列(Sequence) 与 Oracle 序列对比差异分析

《PostgreSQL序列(Sequence)与Oracle序列对比差异分析》PostgreSQL和Oracle都提供了序列(Sequence)功能,但在实现细节和使用方式上存在一些重要差异,... 目录PostgreSQL 序列(Sequence) 与 oracle 序列对比一 基本语法对比1.1 创建序