本文分享自华为云社区《一个Callable接口能有多少知识点？》，作者： 冰 河。
并发编程一直是程序员们比较头疼的，如何编写正确的并发程序相比其他程序来说，是一件比较困难的事情，并发编程中出现的 Bug 往往也是特别诡异的。
之所以说并发编程出现的 Bug 比较诡异，是因为在并发编程中，很多时候出现的 Bug 不一定能完美的复现出来，也就是说，并发编程的 Bug 是很难重现，很难追踪的。
今天，冰河再次带小伙伴们复盘下 Callable 接口，好了，进入今天的正题。
本文纯干货，从源码角度深入解析 Callable 接口，希望大家踏下心来，打开你的 IDE，跟着文章看源码，相信你一定收获不小。
Callable 接口介绍
Callable 接口是 JDK1.5 新增的泛型接口，在 JDK1.8 中，被声明为函数式接口，如下所示。
@FunctionalInterfacepublic 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。
Callable 接口的实现类
接下来，分析的类主要有：PrivilegedCallable、PrivilegedCallableUsingCurrentClassLoader、RunnableAdapter 和 Task 类下的 TaskCallable。虽然这些类在实际工作中很少被直接用到，但是作为一名合格的开发工程师，设置是秃顶的资深专家来说，了解并掌握这些类的实现有助你进一步理解 Callable 接口，并提高专业技能（头发再掉一批，哇哈哈哈。。。）。
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()方法，如下所示。
@CallerSensitivepublic static native <T> T doPrivileged(PrivilegedExceptionAction<T> action, AccessControlContext context) throws PrivilegedActionException;
复制代码
可以看到，又是一个本地方法。也就是说，最终的执行情况是将 PrivilegedExceptionAction 接口对象和 AccessControlContext 对象实例传递给这个本地方法执行。并且在 PrivilegedExceptionAction 接口对象的 run()方法中调用 Callable 接口的 call()方法来执行最终的业务逻辑，并且返回泛型对象。
此类表示为在已经建立的特定访问控制和当前的类加载器下运行的 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 类比较简单，给定运行的任务和结果，运行给定的任务并返回给定的结果，源代码如下所示。
/** * 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 类是 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 对象中，其中，ObjectProperty 在 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); }}
复制代码
点击关注，第一时间了解华为云新鲜技术~
评论