Callable Future接口的设计原理

我们都知道Callable接口作为任务给线程池来执行，可以通过Future对象来获取返回值，他们背后的实现原理是什么？通过总结背后的实现原理有助于我们深入的理解相关技术，做到触类旁通和举一反三。

文章目录

• 　　一、使用示例
• 　　二、工作流程分析
• 　　三、工作流程归纳
• 　　四、FutureTask类设计原理

一、使用示例

先通过一个简单示例来了解Callable如何使用：

public class FutureTaskTest {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        Future<Integer> result = executor.submit(task);
        executor.shutdown();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        System.out.println("主线程在执行任务");

        try {
            System.out.println("task运行结果"+result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("所有任务执行完毕");
    }

    static class Task implements Callable<Integer> {

        public Integer call() throws Exception {
            System.out.println("子线程在进行计算");
            Thread.sleep(30000);
            int sum = 0;
            for(int i=0;i<100;i++)
                sum += i;
            return sum;
        }
    }

}

　　

二、工作流程分析

通过调试代码可知Callable工作流程如下：
1.submit方法接受Callable接口,首先包裹成功FutureTask对象，并作为返回值返回。
2.调用ThreadPoolExecutor.execute方法
2.1 线程池中的工作线程最终执行后会调用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);
        }
    }

2.2 run方法主要是执行Callable接口，并把返回值写入到FutureTask的outcome属性中,并调用LockSupport.unpack方法
3.主线程继续执行。
4.主线程调用FutureTask.get方法获取返回值。
4.1 如果FutureTask计算没有完成，那么需要等待完成,这个时候会调用LockSupport.pack方法阻塞线程

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

三、工作流程归纳

Callable工作流程归纳：
1.submit方法接受Callable接口,首先包裹成功futruetask对象，并作为返回值返回。
2.FutureTask实现了Runnable接口和Future接口。由于实现了Runnable接口（runnable实现方法中会调用Callable接口），可以给线程池执行；future接口管理执行过程，比方说取消，阻塞获取执行结果，判断是否执行完成，是否取消。

所以Callable接口实现的核心是FutureTask，那么FutureTask类的设计原理是什么呢？

四、FutureTask类的设计原理

要理解一个类的设计原理，首先要知道这个类为我们提供了什么功能。通过上面的流程归纳2我们知道，FutureTask给我们提供两个功能？

• 作为一个任务，可以给线程池来执行。
• 能够任务做一些控制：比方说取消，阻塞获取执行结果，判断是否执行完成，是否取消

这里我们重点分析下阻塞获取执行结果必要性和实现思路。

必要性：

如果我们一个后端接口有一些耗时（CPU/IO）的操作需要执行，我们首先能想到的方法是把这些操作并行处理。任务并行处理之后，就有一个线程同步的问题：主线程执行完其他操作后，可能需要获取其他线程的执行结果。如果并行操作还没有完成，主线程需要等待并行操作完成后，才能拿到最终结果。所以Future.get方法是有必要的。

实现思路：

• FutureTask依赖一个Callable接口，这个接口表示具体需要执行的任务。
• 实现Runnable接口，这样就可以交给线程池来实现。
• Runnable接口实现方法中主要做的事情是调用Callable接口完成计算任务，并把结果集返回一个变量中，并更新任务状态。
• FutureTask.get方法，根据任务状态来判断任务是否完成，如果没有完成需要等待任务的完成，完成挂起线程。
• Runnable接口中的任务完成后，会唤醒主线程。
• 主线程继续执行，能获取结果。