本文纯干货，从源码角度深入解析Callable接口，希望大家踏下心来，打开你的IDE，跟着文章看源码，相信你一定收获不小。
1.Callable接口介绍
Callable接口是JDK1.5新增的泛型接口，在JDK1.8中，被声明为函数式接口，如下所示。
@FunctionalInterface
public interface Callable<V> {V call() throws Exception;
}在JDK 1.8中只声明有一个方法的接口为函数式接口，函数式接口可以使用@FunctionalInterface注解修饰，也可以不使用@FunctionalInterface注解修饰。只要一个接口中只包含有一个方法，那么，这个接口就是函数式接口。
在JDK中，实现Callable接口的子类如下图所示。
默认的子类层级关系图看不清，这里，可以通过IDEA右键Callable接口，选择“Layout”来指定Callable接口的实现类图的不同结构，如下所示。
这里，可以选择“Organic Layout”选项，选择后的Callable接口的子类的结构如下图所示。
在实现Callable接口的子类中，有几个比较重要的类，如下图所示。
分别是：Executors类中的静态内部类：PrivilegedCallable、PrivilegedCallableUsingCurrentClassLoader、RunnableAdapter和Task类下的TaskCallable。
2.实现Callable接口的重要类分析
接下来，分析的类主要有：PrivilegedCallable、PrivilegedCallableUsingCurrentClassLoader、RunnableAdapter和Task类下的TaskCallable。虽然这些类在实际工作中很少被直接用到，但是作为一名合格的开发工程师，设置是秃顶的资深专家来说，了解并掌握这些类的实现有助你进一步理解Callable接口，并提高专业技能（头发再掉一批，哇哈哈哈。。。）。
- PrivilegedCallable
PrivilegedCallable类是Callable接口的一个特殊实现类，它表明Callable对象有某种特权来访问系统的某种资源，PrivilegedCallable类的源代码如下所示。
/*** A callable that runs under established access control settings*/
static final class PrivilegedCallable<T> implements Callable<T> {private final Callable<T> task;private final AccessControlContext acc;PrivilegedCallable(Callable<T> task) {this.task = task;this.acc = AccessController.getContext();}public T call() throws Exception {try {return AccessController.doPrivileged(new PrivilegedExceptionAction<T>() {public T run() throws Exception {return task.call();}}, acc);} catch (PrivilegedActionException e) {throw e.getException();}}
}
从PrivilegedCallable类的源代码来看，可以将PrivilegedCallable看成是对Callable接口的封装，并且这个类也继承了Callable接口。
在PrivilegedCallable类中有两个成员变量，分别是Callable接口的实例对象和AccessControlContext类的实例对象，如下所示。
private final Callable<T> task;
private final AccessControlContext acc;其中，AccessControlContext类可以理解为一个具有系统资源访问决策的上下文类，通过这个类可以访问系统的特定资源。通过类的构造方法可以看出，在实例化AccessControlContext类的对象时，只需要传递Callable接口子类的对象即可，如下所示。
PrivilegedCallable(Callable<T> task) {this.task = task;this.acc = AccessController.getContext();
}AccessControlContext类的对象是通过AccessController类的getContext()方法获取的，这里，查看AccessController类的getContext()方法，如下所示。
public static AccessControlContext getContext(){AccessControlContext acc = getStackAccessControlContext();if (acc == null) {return new AccessControlContext(null, true);} else {return acc.optimize();}
}通过AccessController的getContext()方法可以看出，首先通过getStackAccessControlContext()方法来获取AccessControlContext对象实例。如果获取的AccessControlContext对象实例为空，则通过调用AccessControlContext类的构造方法实例化，否则，调用AccessControlContext对象实例的optimize()方法返回AccessControlContext对象实例。
这里，我们先看下getStackAccessControlContext()方法是个什么鬼。
private static native AccessControlContext getStackAccessControlContext();原来是个本地方法，方法的字面意思就是获取能够访问系统栈的决策上下文对象。
接下来，我们回到PrivilegedCallable类的call()方法，如下所示。
public T call() throws Exception {try {return AccessController.doPrivileged(new PrivilegedExceptionAction<T>() {public T run() throws Exception {return task.call();}}, acc);} catch (PrivilegedActionException e) {throw e.getException();}
}通过调用AccessController.doPrivileged()方法，传递PrivilegedExceptionAction。接口对象和AccessControlContext对象，并最终返回泛型的实例对象。
首先，看下AccessController.doPrivileged()方法，如下所示。
@CallerSensitive
public static native <T> TdoPrivileged(PrivilegedExceptionAction<T> action,AccessControlContext context)throws PrivilegedActionException;可以看到，又是一个本地方法。也就是说，最终的执行情况是将PrivilegedExceptionAction接口对象和AccessControlContext对象实例传递给这个本地方法执行。并且在PrivilegedExceptionAction接口对象的run()方法中调用Callable接口的call()方法来执行最终的业务逻辑，并且返回泛型对象。
- PrivilegedCallableUsingCurrentClassLoader
此类表示为在已经建立的特定访问控制和当前的类加载器下运行的Callable类，源代码如下所示。
/*** A callable that runs under established access control settings and* current ClassLoader*/
static final class PrivilegedCallableUsingCurrentClassLoader<T> implements Callable<T> {private final Callable<T> task;private final AccessControlContext acc;private final ClassLoader ccl;PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {SecurityManager sm = System.getSecurityManager();if (sm != null) {sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);sm.checkPermission(new RuntimePermission("setContextClassLoader"));}this.task = task;this.acc = AccessController.getContext();this.ccl = Thread.currentThread().getContextClassLoader();}public T call() throws Exception {try {return AccessController.doPrivileged(new PrivilegedExceptionAction<T>() {public T run() throws Exception {Thread t = Thread.currentThread();ClassLoader cl = t.getContextClassLoader();if (ccl == cl) {return task.call();} else {t.setContextClassLoader(ccl);try {return task.call();} finally {t.setContextClassLoader(cl);}}}}, acc);} catch (PrivilegedActionException e) {throw e.getException();}}
}
这个类理解起来比较简单，首先，在类中定义了三个成员变量，如下所示。
private final Callable<T> task;
private final AccessControlContext acc;
private final ClassLoader ccl;接下来，通过构造方法注入Callable对象，在构造方法中，首先获取系统安全管理器对象实例，通过系统安全管理器对象实例检查是否具有获取ClassLoader和设置ContextClassLoader的权限。并在构造方法中为三个成员变量赋值，如下所示。
PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {SecurityManager sm = System.getSecurityManager();if (sm != null) {sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);sm.checkPermission(new RuntimePermission("setContextClassLoader"));}this.task = task;this.acc = AccessController.getContext();this.ccl = Thread.currentThread().getContextClassLoader();
}接下来，通过调用call()方法来执行具体的业务逻辑，如下所示。
public T call() throws Exception {try {return AccessController.doPrivileged(new PrivilegedExceptionAction<T>() {public T run() throws Exception {Thread t = Thread.currentThread();ClassLoader cl = t.getContextClassLoader();if (ccl == cl) {return task.call();} else {t.setContextClassLoader(ccl);try {return task.call();} finally {t.setContextClassLoader(cl);}}}}, acc);} catch (PrivilegedActionException e) {throw e.getException();}
}在call()方法中同样是通过调用AccessController类的本地方法doPrivileged，传递PrivilegedExceptionAction接口的实例对象和AccessControlContext类的对象实例。
具体执行逻辑为：在PrivilegedExceptionAction对象的run()方法中获取当前线程的ContextClassLoader对象，如果在构造方法中获取的ClassLoader对象与此处的ContextClassLoader对象是同一个对象（不止对象实例相同，而且内存地址也相同），则直接调用Callable对象的call()方法返回结果。否则，将PrivilegedExceptionAction对象的run()方法中的当前线程的ContextClassLoader设置为在构造方法中获取的类加载器对象，接下来，再调用Callable对象的call()方法返回结果。最终将当前线程的ContextClassLoader重置为之前的ContextClassLoader。
- RunnableAdapter
RunnableAdapter类比较简单，给定运行的任务和结果，运行给定的任务并返回给定的结果，源代码如下所示。
/*** A callable that runs given task and returns given result*/
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;}
}- TaskCallable
TaskCallable类是javafx.concurrent.Task类的静态内部类，TaskCallable类主要是实现了Callable接口并且被定义为FutureTask的类，并且在这个类中允许我们拦截call()方法来更新task任务的状态。源代码如下所示。
private static final class TaskCallable<V> implements Callable<V> {private Task<V> task;private TaskCallable() { }@Override public V call() throws Exception {task.started = true;task.runLater(() -> {task.setState(State.SCHEDULED);task.setState(State.RUNNING);});try {final V result = task.call();if (!task.isCancelled()) {task.runLater(() -> {task.updateValue(result);task.setState(State.SUCCEEDED);});return result;} else {return null;}} catch (final Throwable th) {task.runLater(() -> {task._setException(th);task.setState(State.FAILED);});if (th instanceof Exception) {throw (Exception) th;} else {throw new Exception(th);}}}
}从TaskCallable类的源代码可以看出，只定义了一个Task类型的成员变量。下面主要分析TaskCallable类的call()方法。
当程序的执行进入到call()方法时，首先将task对象的started属性设置为true，表示任务已经开始，并且将任务的状态依次设置为State.SCHEDULED和State.RUNNING，依次触发任务的调度事件和运行事件。如下所示。
task.started = true;
task.runLater(() -> {task.setState(State.SCHEDULED);task.setState(State.RUNNING);
});接下来，在try代码块中执行Task对象的call()方法，返回泛型对象。如果任务没有被取消，则更新任务的缓存，将调用call()方法返回的泛型对象绑定到Task对象中的ObjectProperty<V>对象中，其中，ObjectProperty<V>在Task类中的定义如下。
private final ObjectProperty<V> value = new SimpleObjectProperty<>(this, "value");接下来，将任务的状态设置为成功状态。如下所示。
try {final V result = task.call();if (!task.isCancelled()) {task.runLater(() -> {task.updateValue(result);task.setState(State.SUCCEEDED);});return result;} else {return null;}
}
如果程序抛出了异常或者错误，会进入catch()代码块，设置Task对象的Exception信息并将状态设置为State.FAILED，也就是将任务标记为失败。接下来，判断异常或错误的类型，如果是Exception类型的异常，则直接强转为Exception类型的异常并抛出。否则，将异常或者错误封装为Exception对象并抛出，如下所示。
catch (final Throwable th) {task.runLater(() -> {task._setException(th);task.setState(State.FAILED);});if (th instanceof Exception) {throw (Exception) th;} else {throw new Exception(th);}
}
记住：你比别人强的地方，不是你做过多少年的CRUD工作，而是你比别人掌握了更多深入的技能。不要总停留在CRUD的表面工作，理解并掌握底层原理并熟悉源码实现，并形成自己的抽象思维能力，做到灵活运用，才是你突破瓶颈，脱颖而出的重要方向！
最后，作为一名合格（发际线比较高）的开发人员或者资深（秃顶）的工程师和架构师来说，理解原理和掌握源码，并形成自己的抽象思维能力，灵活运用是你必须掌握的技能。
