并发编程学习笔记(11)----FutureTask的使用及实现

1. Future的使用

　　Future模式解决的问题是。在实际的运用场景中，可能某一个任务执行起来非常耗时，如果我们线程一直等着该任务执行完成再去执行其他的代码，就会损耗很大的性能，而Future接口就是Future的实现，它可以让当前线程将任务交给Future去执行，然后当前线程就可以去干别的事，知道耗时任务执行完成之后，当前线程直接获取结果即可。FutureTask的使用比较简单，只需要先实例化一个Callable对象，重写call方法，再创建一个FutureTask对象，将Callable对象传给FutureTask，创建一个线程，将FutureTask对象传入Thread对象，启动线程即可，接下来就直接上源码：

package com.company.thread.t5;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FutureDemo {

    public static void main(String[] args) {

        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println("正在计算结果");
                Thread.sleep(3000);
                return 1;
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        //做点别的
        System.out.println("干点别的");
        try {
            System.out.println("拿到的结果为：" + futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

2. FutureTask源码

　　FutureTask实现了RunnableFuture，而RunnableFuture同时继承了Runnable和Future接口，所以它既是一个任务，也实现了Future接口的功能。

　　从上面使用的步骤来看，我们需要先实例化一个Callable对象，所以先看看Callable接口

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

　　这是一个接口，具体的实现在重写的call方法中，是需要做的任务的方法所在。

　　在使用方法中我们需要将Callable传给FutureTask的构造方法，所以我们先看FutureTask的构造方法：

public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

　　如果callable为空，则抛出异常，否则执行赋值操作，并将state状态改成NEW，即是初始化状态，这里说一下state几种状态所对应的值及意义：

　　

    //表示初始化状态
    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;

　　所以初始化时state的值为0，表示当前为初始化状态。

　　FutureTask实现了Runnable，所以必然又run方法去供线程使用，接下来就看FutureTask重写的run()方法：

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);
        }
    }

　　第一步判断state是否为初始化状态，不为初始化状态将将当前线程设置为FutureTask的执行线程，设置失败停止方法，经过第一步还能往下执行，则当前的state必然是初始化状态，得到Callable实例，及真正需要执行的任务代码，判断是否为空，且状态是否为初始化状态，判断成功，则执行callable的call()方法，并将执行结果赋值给result,将执行标记ran赋值为ture，执行成功时，ran为true时调用set（）方法保存结果，

　　set（）方法：

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

　　将状态从NEW偏移到COMPLETING（正在执行中），将结果保存到outcome中，（outcome是一个Object类型，不止可以保存结果，还可以保存异常信息），保存完成后将偏移量改为NORMAL(正常执行完毕的状态),调用finishCompletion()方法。

　　finishCompletion（）方法：

 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
    }

　　因为在执行过程中可能会未执行完成就调用了get方法，此时get方法会将想要获取结果的线程都等待在一个等待队列中，所以finishCompletion（）的功能就是遍历等待队列，并将等带队列中所有的有效线程唤醒（unpark）。此时等待get（）的线程将会继续执行，

　　当调用call方法出现异常时，result未空，ran赋值未false,调用setException()方法；

　　setException(Throwable t):

 protected void setException(Throwable t) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

　　首先更改状态为COMPLETING，将异常信息保存到outcome中，更改状态为EXCEPTIONAL（表示异常执行结束），调用finishCompletion（）唤醒等待线程。run执行完成；

　　FutureTask还有一个重要的方法就是get()方法，用于获取Callable的call方法返回的结果或执行过程中出现的异常信息。

　　get()：

 public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

　　当状态小于等于COMPLETING时，表示当前任务还没有处于终止状态，即可能正在初始化或者是正在执行中，调用awaitDone()方法将线程放入等待队列，并等待起来，直到被唤醒，最后返回report（s）执行结果，

report（s：

  @SuppressWarnings("unchecked")
    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);
    }

　　如果正常执行结束，返回执行结果，s >= CANCELLED表示线程不可用状态，抛出异常CancellationException，否则就是异常执行结束，抛出ExecutionException（）,这样就可以拿到执行结果。

　　FutureTask其核心的原理也是等待/唤醒，当调用get方法没有结果时，线程等待，当set()方法赋值成功，表示任务执行完成，有值可以返回时，唤醒等待的线程，get（）方法上等待的线程被唤醒，继续执行，最后返回结果。