FutureTask 深度解析

FutureTask 深度解析FutureTask深度解析

大家好,又见面了,我是你们的朋友全栈君。

先看下FutureTask的注释吧

FutureTask一个可取消的异步计算,FutureTask 实现了Future的基本方法,提空 start cancel 操作,可以查询计算是否已经完成,

并且可以获取计算的结果。结果只可以在计算完成之后获取,get方法会阻塞当计算没有完成的时候,一旦计算已经完成,

那么计算就不能再次启动或是取消。

一个FutureTask 可以用来包装一个 Callable 或是一个runnable对象。因为FurtureTask实现了Runnable方法,所以一个
FutureTask可以提交(submit)给一个Excutor执行(excution).

FutureTask 有两个很重要的属性 分别是 state  runner ,futureTask之所以可以支持cancel操作 就是因为这两个属性
其中 state为 枚举值:
NEW                            新建            0
COMPLETING             执行中        1
NORMAL                    正常            2
EXCEPTIONAL            异常            3
CANCELLED                取消            4
INTERRUPTING        中断中        5
INTERRUNPED            被中断        6
state的状态变化可以有四种方式
NEW->COMPLETING->NORMAL                            正常完成的流程
NEW->COMPLETING->EXCEPTIONAL                出现异常的流程
NEW->CANCELED                                                  被取消
NEW->INTERRUNPING->INTERRRUNPTED        被中断

我们研究下Task的状态变化也就是一个任务的生命周期:

我们创建一个FutureTask 首先会调用构造方法:

public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
 }

在我们构造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;
            /**
            * 如果 要执行的任务不为空 并且状态 new 就执行
   
            ***/
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                	//执行任务
                    result = c.call();
                    //如果没有意外发生就执行成功了
                    ran = true;
                } catch (Throwable ex) {
                		//有异常
                    result = null;
                    ran = false;
                    //设置异常
                    setException(ex);
                }
                //如果转型成功了 设置结果
                if (ran)
                    (result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            //不管是否执行成功了 都把runner设置成null
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

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

我们先看下set方法 :

  protected void set(V v) {
    	 	/**
    	 	*如过state是new 把state设置成 COMPLETING
    	 	*
    	 	**/
    	 	
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            //将任务设置成NORMAL   over the task
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }

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

NEW->COMPLETING->NORMAL   

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

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

protected void setException(Throwable t) {
     /**
    	 	*如过state是new 把state设置成 COMPLETING
    	 	*
    	 	**/
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;
             //将任务设置成EXCEPTIONAL 
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

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

NEW->COMPLETING->EXCEPTIONAL 
执行步骤是 首先执行 run() 并且Task抛出异常而且在这其间没有调用cancel()。

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

现在我们分析下cancel()方法先被调用的情况

上cancel()代码吧

/这个方法有一个参数 是否中断running
     public boolean cancel(boolean mayInterruptIfRunning) {
     	  /**
     	  * 这个有点晕啊逻辑关系是
     	  * 等价与 if(state!=new || !UNSAFE.compareAndSwapInt(this, stateOffset, NEW, mayInterruptIfRunning ? INTERRUPTING : CANCELLED))
     	  * 这个意思是 如果state不是new 那么就退出方法,这时的任务任务坑是已经完成了 或是被取消了 或是被中断了
     	  * 如果是state 是new 就设置state 为中断状态 或是取消状态
     	  *
     	  **/
        if (!(state == NEW &&
              UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
                  mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
            return false;
        try {    // in case call to interrupt throws exception
        	//如果是可中断 那么就 调用系统中断方法 然后把状态设置成INTERRUPTED
            if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();
                } finally { // final state
                    UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
                }
            }
        } finally {
            finishCompletion();
        }
        return true;
    }

这个方法很简单 :

1.如果是cancel(false) 那么Task的状态变化就是

 NEW->=CANCELLED

2.如果是cancel(true)那么Task的状态化就是

 NEW->INTERRUPTING ->INTERRUPTED

至此Task的四种状态变化我们都看到了,不过这都是在两个方法都是单独执行的情况。

我们在分析下两个方法交叉执行的情况( run()->cancel() ):

1.如果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状态还没有改变  不会对任务的执行造成影响 只会影响任务的状态 。

2。调用cancel()后 在执行任务 ( cancel() -> run() )

      先调用cancel()无论是那种调用方式都会引起state状态的变化。在run()方法执行的时候发现state已经不是new了 就会放弃任务的执行

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/148294.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • 华为交换机不同网段互访_华为三层交换机实现不同vlan,不同网段的互通

    华为交换机不同网段互访_华为三层交换机实现不同vlan,不同网段的互通实验任务:1.不同vlan,不同网段实现互通;2.路由AR11用默认路由配置;3.LSW8实现三层交换机功能;如下华为拓扑图:配置思路:1.将LSW8看成一个路由器,LSW8下面连接(LSW7和LSW6)的设备都看一个pc,这样就成两个路由互联,下面各接一个pc这样只需让左边的PC7和右边的PC8互通即可搞定:如下图:2.LSW8是三层交换机,先不看192.168.6.0网段和192.168.7….

  • 傅里叶变换与希尔伯特变换的区别_配音演员鱼冻毕业于什么学校

    傅里叶变换与希尔伯特变换的区别_配音演员鱼冻毕业于什么学校1.   傅里叶变换1.1傅里叶变换对周期信号进行傅里叶变换(包括正弦周期和非正弦周期信号,正弦周期实际上利用正交性可以知道,除了对应的频率,其他谐波的积分都是0),可以将信号分解为一个无穷级数的和:其中T为原周期信号的频率,因此,整个傅里叶变换将原信号分解为包括原周期在内的无数个谐波分量的三角集数和。对于非周期信号,实际上,非周期信号可以被理解为周期为无限短的周期信号,因此,级数和也自然变成了积…

    2022年10月19日
  • MySQL——SQL练习题

    MySQL——SQL练习题

  • mac系统webstorm快捷键

    mac系统webstorm快捷键WebStorm是jetbrains公司旗下一款JavaScript开发工具。被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaSscriptIDE”等。与IntelliJIDEA同源,继承了IntelliJIDEA强大的JS部分的功能.现将最常用的快捷键挑出来备忘,既能方便记忆,又能提高工作效率。快捷键作用…

  • 使用Python暴力激活成功教程密码

    使用Python暴力激活成功教程密码由于业务需求,今天项目对接了百度云智能的风控系统,注册和登陆保护,想来测试一下性能,用python写了一个脚本,暴力激活成功教程密码,看看会不会触发风控一、首先在本地新建了一个数据库,保存已经试错过的密码CREATETABLE`test`.`pwd`(`id`int(10)NOTNULLAUTO_INCREMENT,`passwod`varchar(20)CHARACTERSETutf8COLLATEutf8_general_ciNOTNULLDEFAULT’…

  • jboss安装与配置_微信最新版下载并安装

    jboss安装与配置_微信最新版下载并安装jboss有开源和商业两个版本,他们区别如下:JBossAS开源社区版本,发布比较频繁。JBoss7,先后发布了7.0.0,7.0.1,7.0.2,7.1.0,7.1.1,7.1.2,7.1.3,7.2.0,其中7.1.1比较经典,7.2.0是JBossEAP6.1的基础,但7.1.2,7.1.3,7.2.0只是源代码打了Tag,并没提供开放下载。JBossEAP(EnterpriseApplicationPlatform)在开源版本上构建的企业版本,目

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号