TOP

谈谈 Callable 任务是怎么运行的?它的执行结果又是怎么获取的?(三)
2019-09-07 07:09:47 】 浏览:71
Tags:谈谈 Callable 任务 怎么 运行 执行 结果 又是 获取

d)执行,这就回答了本文开头提出的第二个问题。

//java.util.concurrent.RunnableFuture
public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

用一张图表示就是:

Callable任务的设置与获取,则都是在FutureTask这个层面上完成,把Callable封装到FutureTask中,而FutureTask implements Runnable,从而转化成ThreadPoolExecutor#execute执行Runnable任务。

Callable任务的执行结果又是怎么获取的?Future.get为什么会阻塞?

java.util.concurrent.FutureTask 的private volatile int state;变量:

//java.util.concurrent.FutureTask#run
public void run() {
        if (state != NEW ||
            !RUNNER.compareAndSet(this, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    //Callable#call执行成功, ran=true
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                //ran=true,才会设置Callable任务的执行结果
                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方法设置Callable任务的执行结果时,会修改 FutureTask的 state 实例变量的值!

    //java.util.concurrent.FutureTask#set   
    protected void set(V v) {
        if (STATE.compareAndSet(this, NEW, COMPLETING)) {
            outcome = v;
            STATE.setRelease(this, NORMAL); // final state
            finishCompletion();
        }
    }

java.util.concurrent.FutureTask#get()方法,也正是通过检查 state 的值,来确定是否能够拿到Callable任务的执行结果。

    //java.util.concurrent.FutureTask#get()
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            //如果 state 不是在 NORMAL 状态,FutureTask#get()就会阻塞
            //这就是 java.util.concurrent.Future#get() 阻塞的原因
            s = awaitDone(false, 0L);//这里面会调用:Thread.yield()、LockSupport.park(this)
        return report(s);
    }

java.util.concurrent.FutureTask#awaitDone

//java.util.concurrent.FutureTask#awaitDone
private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        WaitNode q = null;
        //省略一些无关代码...
        for (;;) {//for循环一直检查任务的运行状态....直到可以"结束"
            int s = state;
            //state的值大于 COMPLETING 说明已经有Callable任务的结果了
            //java.util.concurrent.FutureTask#set 设置了Callable任务的结果,修改了state的值
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            //COMPLETING 任务的运行状态是:正在执行中
            else if (s == COMPLETING)
                // We may have already promised (via isDone) that we are done
                // so never return empty-handed or throw InterruptedException
                Thread.yield();//挂起获取执行结果的线程(这就是Futur#get阻塞的原因)
            else if (Thread.interrupted()) {
                removeWaiter(q);//任务可能被中断了,当然就不需要等待获取执行结果了
                throw new InterruptedException();
            }
            else if (q == null) {
                if (timed && nanos <= 0L)
                    return s;
                q = new WaitNode();
            }
            else if (!queued)
                queued = WAITERS.weakCompareAndSet(this, q.next = waiters, q);
            //java.util.concurrent.Future#get(long, java.util.concurrent.TimeUnit)超时阻塞的实现原理
            else if (timed) {
                final long parkNanos;
                if (startTime == 0L) { // first time
                    startTime = System.nanoTime();
                    if (startTime == 0L)
                        startTime = 1L;
                    parkNanos = nanos;
                } else {
                    long elapsed = System.nanoTime() - startTime;
                    if (elapsed >= nanos) {
                        removeWaiter(q);
                        return state;
                    }
                    parkNanos = nanos - elapsed;
                }
                // nanoTime may be slow; recheck be  
		
谈谈 Callable 任务是怎么运行的?它的执行结果又是怎么获取的?(三) https://www.cppentry.com/bencandy.php?fid=76&id=250313

首页 上一页 1 2 3 4 下一页 尾页 3/4/4
】【打印繁体】【投稿】【收藏】 【推荐】【举报】【评论】 【关闭】 【返回顶部
上一篇Linux配置使用SSH Key登录并禁用r.. 下一篇Android入门学习教程PDF免费下载