关于并发编程:高并发深入解析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 的外表工作，了解并把握底层原理并相熟源码实现，并造成本人的抽象思维能力，做到灵活运用，才是你冲破瓶颈，怀才不遇的重要方向！

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

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