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

大家好，我是冰河~~

本文纯干货，从源码角度深刻解析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> 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的外表工作，了解并把握底层原理并相熟源码实现，并造成本人的抽象思维能力，做到灵活运用，才是你冲破瓶颈，怀才不遇的重要方向！

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

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

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

1.Callable接口介绍

2.实现Callable接口的重要类剖析

评论

发表回复取消回复

更多文章

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

深入解析：基于Delta的线性数据结构模型，打造高效富文本编辑器

轻松管理社交媒体：使用Automa插件实现一键拉黑功能

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

1.Callable接口介绍

2.实现Callable接口的重要类剖析

评论

发表回复 取消回复

更多文章

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

深入解析：基于Delta的线性数据结构模型，打造高效富文本编辑器

轻松管理社交媒体：使用Automa插件实现一键拉黑功能

发表回复取消回复