并发编程Callable使用及源码分析

并发编程Callable使用及源码分析

一.带返回值的任务Callable介绍

在日常开发中，为了提高应用的处理能力我们经常会使用到线程Executors处理任务，在使用线程池时避免不了需要调用线程池的execute（Runnable）或submit（Callable）；
对于大多数开发人员来说Runable接口并不陌生，实现起来也非常简单，只要实现Runnable接口重写run()方法即可。在日常的开发中使用最多的也是这种方式。但是如果我们想获取一个任务执行后的返回结果那么Runnable接口可能就无法满足我们的需求了，这时就需要使用Callable接口重写call()方法；

二.Callable接口的基本使用和原理分析

1.demo演示

在分析Callable接口在并发环境下的执行流程之前我们先以一个简单的案例来熟悉一下它的使用：

ExecutorService es = Executors.newSingleThreadExecutor();//创建线程池
Future<?> task = es.submit(new MyThread());//这里的MyThread就是一个简单的实现了Callable接口的实现类
try {
    //指定获取任务接口的时间，也可以不指定时间后面会对这个这个进行进行分析
    task.get(5, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    //超时触发线程中止
    System.out.println("thread over time");
} catch (ExecutionException e) {
   //抛出执行异常
    throw e;
} finally {
   //如果任务还在运行，执行中断
    boolean mayInterruptIfRunning = true;
    task.cancel(mayInterruptIfRunning);
}

上面代码是Future的一个简单例子：MyThread实现Callable接口，执行时要求在限定时间内获取结果，超时执行会抛TimeoutException，执行异常会抛出ExecutionException。最后在finally里，如果任务还在执行，就进行取消；如果任务已经执行完，取消操作也没有影响。

2.Future接口分析
从上面的简单案例中我们不难看出，当使用Executors对Callable实现类对象进行提交时需要将Callable对象封装成一个 RunnableFuture task,并最终将task任务进行返回(具体源码后面会进行分析)，我们可以从返回的task对象中获取call()方法的执行结果，继承关系关系如下图所示：

Future接口代表一个异步任务的结果，提供了相应方法判断任务是否完成或者取消。从上图可知，RunnableFuture同时继承了Future和Runnable，是一个可运行、可知结果的任务，FutureTask是具体的实现类。

FutureTask的状态：

private volatile int 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;

FutureTask有7种状态，初始状态从NEW开始，7种状态的转换过程如下图所示：

FutureTask的状态转换取决于run和cancel的先后调用顺序，具体状态流转过程如下所示：
NEW -> COMPLETING -> NORMAL 正常的流程
NEW -> COMPLETING -> EXCEPTIONAL 异常的流程
NEW -> CANCELLED 被取消流程
NEW -> INTERRUPTING -> INTERRUPTED 被中断流程

FutureTask的变量

 /** The underlying callable; nulled out after running */
    private Callable<V> callable;
    /** The result to return or exception to throw from get() */
    private Object outcome; // non-volatile, protected by state reads/writes
    /** The thread running the callable; CASed during run() */
    private volatile Thread runner;
    /** Treiber stack of waiting threads */
    private volatile WaitNode waiters;

callable是要执行的任务，runner是执行任务的线程，outcome是返回的结果（正常结果或Exception结果），waiters的数据结构是WaitNode，保存了Thread和下个WaitNode的引用。waiters保存了等待结果的线程，每次操作只会增减头，所以是一个栈结构，如下所示：
注：waitNode作用，如果一个线程调用FutureTask中的get方法，这个调用FutureTask.get()的线程可能处于阻塞状态。而waitNode节点就是用来保存当前的阻塞线程；

 static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); }
    }

三.执行过程及源码分析
1.创建线程池提交Callable任务

Future<?> task = es.submit(new MyThread());

2. submit(Callable task)方法分析

public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

 protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

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

注：从submit()方法的源码我们可以看出，当提交一个Callable类型的任务后，首先会将Callable对象封装成一个FutureTask类型的对象(上文已经介绍过类FutureTask相关属性)，从源码不难看出初始化FutureTask对象的主要工作是完成callable和state属性的初始化；当然submit方法也支持Runnable对象，只不过需要先将Runnable对象转换成Callable对象；

3.封装futureTask对象执行线程池的execute(ftask)方法

 public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

注：execute()方法实际上才是线程池执行任务的入口方法，在我们使用Runnable类型的任务时会执行进入这个方法，execute()方法是主要任务时根据当前线程池的状态创建核心线程或将任务加入阻塞队列或创建非核心线程或执行拒绝策略，这里不做过多介绍，我们主要关注addWorker()这个方法即可，这个方法是线程吃的核心方法；

4.addWorker()方法追踪

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

注：addWorker()方法首先对task任务和线程池的运次状态进行校验，这个方法的核心代码为 w = new Worker(firstTask)，创建了一个Worker对象：

 Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

Worker对象本身就是一个Runnable的实现类，同时将自己赋值给了当前线程 this.thread = getThreadFactory().newThread(this)，这一点十分重要；

   t.start();//启动线程执行，上面我们知道当前线程是Worker对象，所以这时调用的应该是worker对象的run()方法；
  

5.线程池执行具体task

  public void run() {
            runWorker(this);
        }

   final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

注：到这里已经非常清晰了，在runWorker(Worker w)方法中调用了 task.run()方法执行具体的任务。这里需要大家注意：
如果task属于Runnable则直接调用重写的run()方法即可。
如果task属于Callable则会调用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);
        }
    }

在FutureTask类的run()方法中调用了result = c.call()，这样就调用我们最开始提交的Callable对象的call()方法，并得到了返回结果result ，并使用 UNSAFE魔术类的方式在保证原子性的情况下设置当前任务的返回值 outcome = v，代码如下所示：

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

6.FutureTask获取结果

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

public V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
    if (unit == null)
        throw new NullPointerException();
    int s = state;
    if (s <= COMPLETING &&
        (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
        throw new TimeoutException();
    return report(s);
}

调用FutureTask的get方法获取任务的执行结果，可以阻塞直到获取结果，也可以限制范围时间内获取结果，否则抛出TimeoutException。
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;
    for (;;) {
        if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }

        int s = state;
        if (s > COMPLETING) {    //1
            if (q != null)
                q.thread = null;
            return s;
        }
        else if (s == COMPLETING) // cannot time out yet    //2
            Thread.yield();
        else if (q == null)     //3
            q = new WaitNode();
        else if (!queued)    //4
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                 q.next = waiters, q);
        else if (timed) {    //5
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos);
        }
        else     //6
            LockSupport.park(this);
    }
}

awaitDone主要逻辑是一个无限循环，首先判断线程是否被中断，是的话移除waiter并抛出中断异常。接下来是一串if-else，一共六种情况。

判断任务状态是否已经完成，是就直接返回；
任务状态是COMPLETING，代表在set结果时被阻塞了，这里先让出资源；
如果WaitNode为空，就为当前线程初始化一个WaitNode；
如果当前的WaitNode还没有加入waiters，就加入；
如果是限定时间执行，判断有无超时，超时就将waiter移出，并返回结果，否则阻塞一定时间；
如果没有限定时间，就一直阻塞到下次被唤醒。
LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。park和unpark的作用分别是阻塞线程和解除阻塞线程。

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

四.扩展
FutureTask中还封装了关于取消，中断，唤醒等方法，大家可以自己尝试跟踪一下源码，看看具体的实现方法。