Future三重奏第三章:FutureTask中一些知识点的总结

Future系列文章

Future三重奏第一章:Future设计模式及代码示例
Future三重奏第二章:FutureTask源码解析
Future三重奏第三章:FutureTask中一些知识点的总结与补充

关于FutureTask源码状态的转变

    private volatile int state;//任务当前的状态
    private static final int NEW          = 0;//初始化时是NEW
    private static final int COMPLETING   = 1;//任务完成但是尚未赋值给outcome
    private static final int NORMAL       = 2;//任务完成且赋值给outcome
    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对象中不同阶段时对象的状态，state是volatile变量修饰的，所以该变量对于所有子线程是可见的，所有子线程共同操作这一个对象变量，下面接着看state状态的改变

 * NEW -> COMPLETING -> NORMAL------1
 * NEW -> COMPLETING -> EXCEPTIONAL------2
 * NEW -> CANCELLED------3
 * NEW -> INTERRUPTING -> INTERRUPTED------4

情况1：代表了最正常的情况，对象创建后初始化，任务完成state转变为COMPLETING，异步计算结果赋值给outcome，状态转变为NORMAL
情况2：在执行call方法时抛出了异常，代码执行setException方法，会将state赋值EXCEPTIONAL

Callable作用

• Callback作用：作用类似于runnable，都是实现了对异步调用的执行方法，区别是runnable不会返回异步调用的结果，但是callback可以返回异步调用结果，自定义类需要实现calllable方法，并重写call方法，实现异步事件的计算，call方法中书写业务代码，相当于realData类的功能
• 在futureTask源码中的使用场景：在构建futureTask对象的构造方法的时候，传入的参数就是实现了callable接口的实体类，在run方法中，通过调用call()方法来获取

在FutureTask对象中，是如何获取计算结果并赋值的

public void run() {
        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;
                    setException(ex);
                }
                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);
        }
    }

• 获取值：在线程启动后调用futureTask对象的run方法，需要注意的是，我们在创建业务类的时候，是需要实现callable接口的，这是futureTask对象可以拿到返回值最重要的一步，通过上述的源码我们发现，在run方法中，通过调用call方法获取到返回值，这里的result 实际就是业务类的返回结果。

FutureTask中WaitNode的作用及详细的处理细节

/**
     * Simple linked list nodes to record waiting threads in a Treiber
     * stack.  See other classes such as Phaser and SynchronousQueue
     * for more detailed explanation.
     */
    static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); }
    }

    /**
     * 唤起所有被挂起的线程
     */
    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 gc
                    q = next;
                }
                break;
            }
        }

        done();

        callable = null;        // to reduce footprint
    }

• WaitNode是一个链表结构，变量都是volatile类型，表示内存中其他子线程也可以在第一时间感受到waitNode更改的变化，cas可以通过计算内存偏移量来把最新的waitNode对象加入到链表的首位，并将首位的node指向之前的node元素
• WaitNode对象的创建
  在futureTask对象调动get方法的时候,如果任务还没有结束，那么当前线程就会被包装成WaitNode对象，并且加入到队列当中，阻塞当前线程
• WaitNode对象在内存中的获取:
  waitersOffset = UNSAFE.objectFieldOffset(k.getDeclaredField("waiters"));该方法是获取waiters在当前futureTsk对象中的地址偏移量，通过该方法可以获取当前futureTask中的waiters对象，所以在finishCompletion方法中，释放的是当前futureTask对象中所有挂起的线程；

• 如果我的文章确实有帮助到你，请不要忘了点一下文末的喜欢
• 技术理解不到或有错误请直(bu)接(yao)指(ma)出(wo)
• 写作不易！