关于并发编程:高并发深入解析Callable接口

大家好，我是冰河~~

本文纯干货，从源码角度深刻解析Callable接口，心愿大家踏下心来，关上你的IDE，跟着文章看源码，置信你肯定播种不小。

1.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。

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()办法，如下所示。

@CallerSensitivepublic static native <T> T    doPrivileged(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的外表工作，了解并把握底层原理并相熟源码实现，并造成本人的抽象思维能力，做到灵活运用，才是你冲破瓶颈，怀才不遇的重要方向！

最初，作为一名合格（发际线比拟高）的开发人员或者资深（秃顶）的工程师和架构师来说，了解原理和把握源码，并造成本人的抽象思维能力，灵活运用是你必须把握的技能。

好了，明天就到这儿吧，我是冰河，咱们下期见~~