Runable和Callable的区别？你必须要搞清楚Thread以及FutureTask！

Runable与Callable的区别，据说是高频面试题，什么样的答案才会让面试官满意呢？

所有java程序员都知道的答案是基于：

public interface Runnable {
    
    public abstract void run();
}

public interface Callable<V> {
    V call() throws Exception;
}

从Runable和Callable接口的定义我们就能知道的是：

Runable接口的run方法不返回结果，不允许他的实现类抛出异常。

Callable接口的call方法可以返回结果，并且允许抛出异常。

再和Thread关联一下，可以补充：

1. 新创建一个线程Thread执行Runable可以实现异步调用，调用线程在创建新线程执行Runable任务之后可以立即获得执行权，不影响后续任务的执行
2. Callable可以被封装在FutureTask（Runable的实现类）中从而被Thread调用，这种情况下调用线程可以通过FutureTask.get()方法获取到Callable接口的call方法的返回值，但是FutureTask.get()方法是阻塞调用，直到线程执行完成才会有结果返回，所以调用线程如果执行了FutureTask.get()的话，后续任务就必须等待

如果单从这个问题来讲，答案应该就差不多完整了。但是如果面试官老爷还想了解细节，那我们就必须要对FutureTask甚至Executor做一个深入的了解。

其实我们并不是为了回答这个面试问题才去研究这部分内容的，而是因为接下来准备认真学习、研究一下线程池、连接池等池化技术，而FutureTask、Executor是线程池技术的基础，所以我们就需要首先搞清楚FutureTask和Executor的底层原理，顺道也许正好能把这个高频java基础面试题回答清楚。

进入正题。今天的内容包括：

1. Thread：概念性的简单说明，不涉及启动、停止、中断、挂起等等状态转换机制
2. FutureTask源码分析

Thread简要说明

Java程序是以线程来运行的，JVM允许一个java应用启动多个线程，当我们的程序以main方法启动之后，其实JVM就启动了一个线程来执行程序。

每一个java thread都有优先级，在资源争夺过程中高优先级线程比低优先级线程更容易获得执行权。线程可以被标注为是否为守护线程，默认情况下，新创建的线程和创建他的线程拥有相同的优先级，当前仅当创建线程是守护线程的时候，被创建的新线程才能是守护线程。

JVM启动的时候，通常会创建一个非守护线程（主线程），主线程会持续运行直到：

1. Runtime的exit方法执行，或者应用抛出的异常一直被传递到主线程的run方法
2. 所有非守护线程执行完毕：run方法正常执行完成或捕获到异常

有两种创建线程的方式：

1. 创建一个Thread类的子类并覆盖他的run方法，然后调用子类对象的start方法，最终子类的run方法会被调用执行
2. 创建Runable接口的实现类，作为参数传递给Thread的构造器创建Thread并执行start方法，最终Runable实现类的run方法会被调用执行

常见的是第2种方法。

FutureTask

先看一下FutureTask的类图：

第一点需要知道的是，FutureTask是Runable接口的实现。

同时他还实现了Future接口，所以我们需要首先简单了解一下Future，看一下JavaDoc：

体现异步任务的执行结果，提供方法检查任务是否完成、等待异步任务执行完成、并获取执行结果。执行结果只能通过get方法获取，只有任务完成后才能获取到，否则会阻塞等待任务完成后返回结果。通过cancel方法可以取消任务，Future还提供了一些其他方法可以帮助获取到任务是正常结束、还是被取消掉了，一旦任务执行完成，则不再允许取消。如果你只是想通过Future来实现任务可以被取消这一特性、而并不在意任务的返回结果，让Future的任务返回null即可。

所以我们知道Future是为了获取到异步任务的执行结果而生的。

FutureTask的任务

FutureTask包含一个叫callable的Callable成员变量，就是FutureTask的底层任务，我们首先看一下这个底层任务是怎么被创建或者初始化的。

先来看FutureTask对象的创建，FutureTask提供了两个构造方法：

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

   public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

其中一个构造方法传入Callable对象，直接赋值给成员变量callable，设置state=NEW，简单明了。

另外一个构造方法传入Runable对象，以及一个result对象，FutureTask首先调用Executors的callable方法把传入的Runable对象包装成一个Callable对象，然后把包装好的Callable对象赋值给成员变量callable，设置state=NEW，结束。

所以我们知道，Future的底层任务只能是Callable对象，但是他也可以接收Runable对象，他自己内部负责将Runable封装成Callable，对调用方来说是透明的。

Runable封装为Callable

Runable是通过Executors的callable方法封装为Callable的，最终生成了一个RunnableAdapter对象：

  static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

从源码可以看到RunnableAdapter实现了Callable接口，将Callable的call方法调用转换为对Runable对象的run方法调用，call方法的返回结果实际上是调用方传进来的。

Runable对象被这样封装之后，也就具备了通过Thread异步调用之后可以通过Future的get方法阻塞获取返回的特性了，我们需要知道，阻塞是真的，这个返回结果result其实是你在创建FutureTask对象的时候传进去的那个result，任务执行完成后原样返回。

FutureTask的状态

FutureTask的状态state：

    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;

对象创建后状态为NEW，任务被线程调起后变更为COMPLETING，任务正常执行完成后为NORMAL，执行过程中抛出异常为EXCEPTIONAL，任务被取消为CANCELLED，任务被中断为INTERRUPTING->INTERRUPTED。

FutureTask的线程安全性

我们需要注意一点，FutureTask位于java.util.concurrent包下，通过UNSAFE的CAS操作以及自旋来确保线程安全线。

提前了解一下FutureTask的另外一个成员变量runner，其实就是执行callable任务的线程，初始化为null，FutureTask构造函数也没有初始化过，所以FutureTask对象创建之后应该也是null：

private volatile Thread runner;

我们在进行后续代码分析之前需要首先了解一下FutureTask定义的几个UNSAFE对象：

private static final sun.misc.Unsafe UNSAFE;
    private static final long stateOffset;
    private static final long runnerOffset;
    private static final long waitersOffset;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> k = FutureTask.class;
            stateOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("state"));
            runnerOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("runner"));
            waitersOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("waiters"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }

stateOffset：对应状态state的内存地址
runnerOffset：对应线程runner的内存地址
waitersOffset：对应阻塞对象waiters的内存地址

伪代码Demo

为了方便描述，我们以下面的伪代码举例：

    //假设MyCallable是我们自己的任务
    Callable callable=new MyCallable();
    FutureTask f1=new FutureTask(callable);
    Thread t1= new Thread(f1);
    t1.start();
    Object o = f1.get();
    ...

其中MyCallable就是我们自己的Callable实现类，篇幅关系，就不贴出所有的代码了。

这个例子中会涉及到两个线程，一个是主线程我们称之为tmain，另外一个是执行FutureTask f1的线程我们称之为t1。

FutureTask的run方法

通过t1.start启动线程t1后，FutureTask的run方法会被调用。

FutureTask的run方法代码其实不长，但是为了容易理解，我们还是分段分析：

if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;

首先是判断当前状态如果不等于NEW则返回，第二句UNSAFE.compareAndSwapObject方法的意思是：直接通过JVM查看runner是否是null，如果是null的话赋值为当前Thread，不是null则直接返回。

这个时候runner就是任务执行线程t1了。

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

然后通过调用callable的call方法执行任务，返回赋给result对象。如果执行成功的话，调用set方法，发生异常则调用setException(ex)进行异常处理。

我们重点看一下set(result)方法：

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

状态state首先修改为COMPLETING，执行结果result赋值给outcome，为get方法的返回做准备。之后state修改为最终状态NORMAL，最后调用finishCompletion()方法。

FutureTask#get方法

get方法是FutureTask的灵魂，如果任务尚未执行完成则get方法一直阻塞直到完成。

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

如果状态小于等于COMPLETING则调用awaitDone方法，否则调用report方法返回结果。

那一定是awaitDone方法实现阻塞等待的。

FutureTask#awaitDone方法

Awaits completion or aborts on interrupt or timeout.
等待任务完成，或者由于中断、超时后放弃

首先for循环自旋：

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

如果当前线程被中断，从watiers队列释放本次的WaitNode、抛出异常。

判断当前状态如果大于COMPLETING则释放当前等待队列q对应的Thread后，返回，否则如果状态等于COMPLETING，说明任务还没有完成（没到最终状态NORMAL），通过调用Thread.yield()继续等待。否则，state应该就小于COMPLETING，说明任务还在执行中，如果排队队列q为null的话创建队列q=new WaitNode();否则，如果尚未排队（!queued）则q加入waiters队列。否则，调用LockSupport.part方法挂起当前线程等待唤醒。

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

代码show完了，我们接下来分析一下这段代码的逻辑：
第一步，我们需要首先明确一下这段代码执行的时候的“当前线程”是谁？

很明显，当前线程不是t1,而是我们上面示例代码的主线程tmain。

第二步，如果当前线程被中断，则从waiters中移出本次加入的WaitNode后抛出中断异常。

否则，如果状态变大于COMPLETING，则将当前WaitNode的线程置空直接返回。

否则如果状态为COMPLETING，则表明任务执行线程已经完成任务的执行、FutureTask尚未完成清场处理所以尚未达到最终状态，则调用Thread.yield();继续等待。

否则，t1线程还没有执行完成任务FutureTask f1，创建一个等待对象WaitNode，WaitNode对象会持有当前线程tmain：

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

第三步，继续自旋，如果FutureTask状态仍然小于COMPLETING，则将WaitNode加入到等待队列waiters中。

第四步，继续自旋，如果FutureTask状态仍然小于COMPLETING，调用LockSupport.park(this);交出tmain线程的控制权，我们知道park方法后当前线程tmain会被挂起（处于Waiting状态或sleep状态），只能通过其他线程调用当前线程的unpark才会被唤醒。

这样我们就很清楚的知道了get方法的逻辑：

1. 如果t1线程已经执行完成并且FutureTask已经到了最终状态，get方法可以立刻返回
2. 否则，如果t1线程已经执行完成但是FutureTask还没有到最终状态（FutureTask的扫尾工作没完成），通过调用Thread.yield方法等待t1线程将FutureTask执行到最终状态
3. 否则，t1线程没有执行完成，则创建WaitNode对象持有当前线程，并将WaitNode对象加入waiters队列；通过LockSupport.park将调用线程tmain挂起，等待唤醒

我们现在的问题是要找到tmain怎么被唤醒？

FutureTask#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
    }

从源码可以看出finishCompletion方法的逻辑：

1. 通过原子操作从waiters中获取WaitNode q
2. 从q中获取其持有的线程t，如果该线程不空的话，调用LockSupport.unpark(t)唤醒该线程
3. q的下一个节点next为空的话结束循环
4. 否则，q指向下一个节点

关键在第2步，大概的意思是说，我执行完成之后，所有那些由于等待我执行完成而自动挂起自己的哥们，都可以被唤醒了。

接下来就是需要验证一下finishCompletion方法在什么地方被调用：一个是cancel方法，通过FutureTask取消任务；另外一个是set（V result）方法,在run方法成功执行完成后；还有一个是setException方法，在run方法执行异常的时候。

真相大白！

小结

FutureTask的主要代码逻辑就分析完成了，对于FutureTask的底层逻辑应该也就有了一个深入的了解了。这个时候如果回过头再来看Runable和Callable的区别的话，应该就会有更清晰的认识了。

Thanks a lot!

上一篇 Quartz - 集群Cluster的配置、failOver原理
下一篇 BlockQueue - 基于TransferStack的SynchronousQueue