解开Future的神秘面纱之获取结果

博客园首页 William 86浏览 0评论

前言

  在前面的两篇博文中,已经介绍利用FutureTask任务的执行流程,以及利用其实现的cancel方法取消任务的情况。本篇就来介绍下,线程任务的结果获取。

利用get方法获取程序运行结果

  我们知道利用Future接口的最重要的操作就是要获取任务的结果,而此操作对应的方法就是get。但是问题来了,如果我调用get方法的时候,任务还没有完成呢?答案就是,等它完成,当前线程将被阻塞,直到任务完成(注意,这里说的完成,指的是任务结束,因为异常而结束也算),get方法返回。主线程(不是执行任务的线程)才被唤醒,然后继续运行。

 

灵活的get方法

  有人可能会问,如果我调用get方法的时候,任务离完成还需要很长时间,那么我主线程不是会浪费一些时间?是的,如果主线程比较忙的话,这样确实主线程的效率。不过还有一个有参的get方法,此方法以等待时长为参数,如果时长结束,任务还没完成,主线程将继续执行,然后会在之后的某个时间再来获取任务结果。(当然如果主线程依赖这个任务结果才能继续执行,那么只能老老实实地等了

FutureTask的阻塞模型

  要想了解get方法的具体实现,必须先弄清楚,它是如何阻塞的。前篇博文已经提到,FutureTask有类型为WaitNode字段waiters,实际上这个waiters引用的是一个以WaitNode为节点的单向链表的头节点。如图所示:

waitNode类代码如下:

static final class WaitNode {
    volatile Thread thread; //线程
    volatile WaitNode next; //下一个节点
    //构造函数获取当前执行线程的引用
    WaitNode() { thread = Thread.currentThread(); }
}

WaitNode保留线程引用的作用是什么?

答案是用于任务完成后唤醒等待线程。当FutureTask执行完callable的run方法后,将执行finishCompletion方法通知所有等待线程

private void finishCompletion() {
    //遍历等待节点
    for (WaitNode q; (q = waiters) != null😉 {
        //将FutureTask的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 gc
                q = next;
            }
            break;
        }
    }

    //调用钩子函数done,此为空方法,子类可根据需求进行实现
    done();

    callable = null;       
}

线程的阻塞方式——park和unPark

  park/unPark也是用于控制线程等待状态的。我们熟悉的,用于控制线程等待状态的还有wait/notify。wait/notify是某个对象的条件队列,要阻塞线程,或者说要加入等待队列,必须先获取对象的锁。

       与wait()/notify不同的是,park和unpark直接操作线程,无需获取对象的锁,个人认为这是这里使用park/unPark,而不是wait/notifyAll的原因,因为获取锁需要额外的开销

get方法的具体实现

以下是FutureTask中get方法的实现

public V get() throws InterruptedException, ExecutionException {
    //获取当前任务状态
    int s = state;
    //如果是NEW或者COMPLETING,也就是还没有结束,就调用awaitDone进行阻塞
    if (s <= COMPLETING)
        s = awaitDone(false, 0L); //注意,这里的参数,表示非超时等待,如果任务未结束,程序将一直卡在这里
    //如果awaitDone返回,也就是任务已经结束,根据任务状态,返回结果
    return report(s);
}

以下是get方法中调用到的awaitDone的实现

private int awaitDone(boolean timed, long nanos) throws InterruptedException {
    //根据超时时间,计算结束时间点
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    //等待节点
    WaitNode q = null;
    //是否加入等待队列
    boolean queued = false;
    //这里并不是通过自旋,使方法无法返回。而是利用自旋CAS, 改变状态。如果成功,一次就够了
    for (;;) {
        //如果此线程被中断,把从节点从等待队列中移除
        if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }

        int s = state;
        //如果状态大于COMPLETING,也就是任务已结束,返回任务状态
        if (s > COMPLETING) {
            if (q != null)
                q.thread = null;
            return s;
        }
        else if (s == COMPLETING) // cannot time out yet
            Thread.yield();
        //第一次循环,q是null,创建节点
        else if (q == null)
            q = new WaitNode();
        //如果还未加入等待队列,就加入
        else if (!queued)
            //q.next = waiters 表达式的返回值 是左侧的值,也就是waiters
            //意思是,如果当前对象的waiters的值是waiters, 就将他赋值为q
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                 q.next = waiters, q); 
        //如果是超时等待,则调用parkNanos, 线程将在指定时间后被唤醒
        else if (timed) {
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos);
        }
        //如果不是超时等待,且已经加入等待队列,这时候利用park将当前线程挂起
        else
            LockSupport.park(this);
    }
}

很多人可能会觉得这个循环体,看着有点迷糊,我刚开始也看得头大。但是我们可以根据几种情境,来查看这几种情境下代码的执行情况。

注:第二个for循环内,第二个if-else块是一个大块,每次只执行一个。

几种执行情境

一、当前线程成功加入等待队列,且被阻塞,一段时间后任务完成,线程被唤醒

 

 

二、当前线程加入队列后,还没被阻塞,任务就已经完成了

三、因为其他线程加入等待队列的影响,当前线程未能加入等待队列

这里说明一下,如果其他线程在此线程之前,比较接近的时间,加入了等待队列,由于内存可见性的原因,当前线程看到的waiters值没有及时改变,故与其实际值不同,CAS操作就将失败。

为什么一定要CAS成功?答案是,如果不成功,出现线程安全问题,链表的结构就会一塌糊涂。这里不细谈。

 

根据任务状态获取结果

   我们已经知道,FutureTask有一个Object字段的outcome,也就是任务执行的结果。当任务完成后,会将结果赋值给它。以下是FutureTask的run方法:

public void run() {
    //任务开始执行后,设置FutureTask的runner字段,指明执行它的线程
    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 ex) {
                result = null;
                //如果运行任务过程中出现异常,则ran=false 表示没有运行完成
                ran = false;
                //设置异常 => 将任务状态设置为异常,并将异常信息赋值给outcome, 也就是任务结果
                //这个方法会调用finishCompletion
                setException(ex);
            }
            //如果运行完成,把结果赋值给outcome
            if (ran)
                set(result); //这个方法会调用finishCompletion
        }
    } finally {
        //既然线程已经"完成"当前任务,就放弃引用,防止影响它执行其他任务
        runner = null; 
        //重新获取任务状态
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

由前文可知,当任务”完成”的时候,获取结果的线程将被唤醒。回到get方法,它将获取到任务的状态,并根据任务状态获取结果。也就是report方法:

private V report(int s) throws ExecutionException {
    //获取结果
    Object x = outcome;
    //如果任务正常完成
    if (s == NORMAL)
        //强制转换为对应类型并返回
        return (V)x;
    //如果任务状态为CANCELLED、INTERRUPTING、INTERRUPTED表明是通过cacel方法取消了
    //返回已取消异常
    if (s >= CANCELLED)
        throw new CancellationException();
    //如果是因为异常中断的话,抛出具体异常信息
    throw new ExecutionException((Throwable)x);
}

 


注:www2014.aspxhtml.com转载自cnblogs,若看不到图片,请移步来源网址查看。
via:https://www.cnblogs.com/longfurcat/p/9906437.html

转载请注明:AspxHtml学习分享网 » 解开Future的神秘面纱之获取结果

发表我的评论
取消评论

表情

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址