CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章一个 Callable 接口能有多少知识点？由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

并发编程一直是程序员们比较头疼的，如何编写正确的并发程序相比其他程序来说，是一件比较困难的事情，并发编程中出现的 Bug 往往也是特别诡异的.

之所以说并发编程出现的 Bug 比较诡异，是因为在并发编程中，很多时候出现的 Bug 不一定能完美的复现出来，也就是说，并发编程的 Bug 是很难重现，很难追踪的.

今天，冰河再次带小伙伴们复盘下Callable接口，好了，进入今天的正题.

本文纯干货，从源码角度深入解析Callable接口，希望大家踏下心来，打开你的IDE，跟着文章看源码，相信你一定收获不小.

Callable接口介绍

Callable接口是JDK1.5新增的泛型接口，在JDK1.8中，被声明为函数式接口，如下所示.

1. @FunctionalInterface
2. public interface Callable {
3. V call() throws Exception;
4. }

在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

PrivilegedCallable类是Callable接口的一个特殊实现类，它表明Callable对象有某种特权来访问系统的某种资源，PrivilegedCallable类的源代码如下所示.

1. /**
2. * A callable that runs under established access control settings
3. */
4. static final class PrivilegedCallable implements Callable {
5. private final Callable task;
6. private final AccessControlContext acc;
7.  
8. PrivilegedCallable(Callable task) {
9. this.task = task;
10. this.acc = AccessController.getContext();
11. }
12.  
13. public T call() throws Exception {
14. try {
15. return AccessController.doPrivileged(
16. new PrivilegedExceptionAction () {
17. public T run() throws Exception {
18. return task.call();
19. }
20. }, acc);
21. } catch (PrivilegedActionException e) {
22. throw e.getException();
23. }
24. }
25. }

从PrivilegedCallable类的源代码来看，可以将PrivilegedCallable看成是对Callable接口的封装，并且这个类也继承了Callable接口.

在PrivilegedCallable类中有两个成员变量，分别是Callable接口的实例对象和AccessControlContext类的实例对象，如下所示.

1. private final Callable task;
2. private final AccessControlContext acc;

其中，AccessControlContext类可以理解为一个具有系统资源访问决策的上下文类，通过这个类可以访问系统的特定资源。通过类的构造方法可以看出，在实例化AccessControlContext类的对象时，只需要传递Callable接口子类的对象即可，如下所示.

1. PrivilegedCallable(Callable task) {
2. this.task = task;
3. this.acc = AccessController.getContext();
4. }

AccessControlContext类的对象是通过AccessController类的getContext()方法获取的，这里，查看AccessController类的getContext()方法，如下所示.

1. public static AccessControlContext getContext(){
2. AccessControlContext acc = getStackAccessControlContext();
3. if (acc == null) {
4. return new AccessControlContext(null, true);
5. } else {
6. return acc.optimize();
7. }
8. }

通过AccessController的getContext()方法可以看出，首先通过getStackAccessControlContext()方法来获取AccessControlContext对象实例。如果获取的AccessControlContext对象实例为空，则通过调用AccessControlContext类的构造方法实例化，否则，调用AccessControlContext对象实例的optimize()方法返回AccessControlContext对象实例.

这里，我们先看下getStackAccessControlContext()方法是个什么鬼.

1. private static native AccessControlContext getStackAccessControlContext();

原来是个本地方法，方法的字面意思就是获取能够访问系统栈的决策上下文对象.

接下来，我们回到PrivilegedCallable类的call()方法，如下所示.

1. public T call() throws Exception {
2. try {
3. return AccessController.doPrivileged(
4. new PrivilegedExceptionAction () {
5. public T run() throws Exception {
6. return task.call();
7. }
8. }, acc);
9. } catch (PrivilegedActionException e) {
10. throw e.getException();
11. }
12. }

通过调用AccessController.doPrivileged()方法，传递PrivilegedExceptionAction。接口对象和AccessControlContext对象，并最终返回泛型的实例对象.

首先，看下AccessController.doPrivileged()方法，如下所示.

1. @CallerSensitive
2. public static native T
3. doPrivileged(PrivilegedExceptionAction action ,
4. AccessControlContext context)
5. throws PrivilegedActionException;

可以看到，又是一个本地方法。也就是说，最终的执行情况是将PrivilegedExceptionAction接口对象和AccessControlContext对象实例传递给这个本地方法执行。并且在PrivilegedExceptionAction接口对象的run()方法中调用Callable接口的call()方法来执行最终的业务逻辑，并且返回泛型对象.

• PrivilegedCallableUsingCurrentClassLoader

此类表示为在已经建立的特定访问控制和当前的类加载器下运行的Callable类，源代码如下所示.

1. /**
2. * A callable that runs under established access control settings and
3. * current ClassLoader
4. */
5. static final class PrivilegedCallableUsingCurrentClassLoader implements Callable {
6. private final Callable task;
7. private final AccessControlContext acc;
8. private final ClassLoader ccl;
9.  
10. PrivilegedCallableUsingCurrentClassLoader(Callable task) {
11. SecurityManager sm = System.getSecurityManager();
12. if (sm != null) {
13. sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
14. sm.checkPermission(new RuntimePermission("setContextClassLoader"));
15. }
16. this.task = task;
17. this.acc = AccessController.getContext();
18. this.ccl = Thread.currentThread().getContextClassLoader();
19. }
20.  
21. public T call() throws Exception {
22. try {
23. return AccessController.doPrivileged(
24. new PrivilegedExceptionAction () {
25. public T run() throws Exception {
26. Thread t = Thread.currentThread();
27. ClassLoader cl = t.getContextClassLoader();
28. if (ccl == cl) {
29. return task.call();
30. } else {
31. t.setContextClassLoader(ccl);
32. try {
33. return task.call();
34. } finally {
35. t.setContextClassLoader(cl);
36. }
37. }
38. }
39. }, acc);
40. } catch (PrivilegedActionException e) {
41. throw e.getException();
42. }
43. }
44. }

这个类理解起来比较简单，首先，在类中定义了三个成员变量，如下所示.

1. private final Callable task;
2. private final AccessControlContext acc;
3. private final ClassLoader ccl;

接下来，通过构造方法注入Callable对象，在构造方法中，首先获取系统安全管理器对象实例，通过系统安全管理器对象实例检查是否具有获取ClassLoader和设置ContextClassLoader的权限。并在构造方法中为三个成员变量赋值，如下所示.

1. PrivilegedCallableUsingCurrentClassLoader(Callable task) {
2. SecurityManager sm = System.getSecurityManager();
3. if (sm != null) {
4. sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
5. sm.checkPermission(new RuntimePermission("setContextClassLoader"));
6. }
7. this.task = task;
8. this.acc = AccessController.getContext();
9. this.ccl = Thread.currentThread().getContextClassLoader();
10. }

接下来，通过调用call()方法来执行具体的业务逻辑，如下所示.

1. public T call() throws Exception {
2. try {
3. return AccessController.doPrivileged(
4. new PrivilegedExceptionAction () {
5. public T run() throws Exception {
6. Thread t = Thread.currentThread();
7. ClassLoader cl = t.getContextClassLoader();
8. if (ccl == cl) {
9. return task.call();
10. } else {
11. t.setContextClassLoader(ccl);
12. try {
13. return task.call();
14. } finally {
15. t.setContextClassLoader(cl);
16. }
17. }
18. }
19. }, acc);
20. } catch (PrivilegedActionException e) {
21. throw e.getException();
22. }
23. }

在call()方法中同样是通过调用AccessController类的本地方法doPrivileged，传递PrivilegedExceptionAction接口的实例对象和AccessControlContext类的对象实例.

具体执行逻辑为：在PrivilegedExceptionAction对象的run()方法中获取当前线程的ContextClassLoader对象，如果在构造方法中获取的ClassLoader对象与此处的ContextClassLoader对象是同一个对象(不止对象实例相同，而且内存地址也相同)，则直接调用Callable对象的call()方法返回结果。否则，将PrivilegedExceptionAction对象的run()方法中的当前线程的ContextClassLoader设置为在构造方法中获取的类加载器对象，接下来，再调用Callable对象的call()方法返回结果。最终将当前线程的ContextClassLoader重置为之前的ContextClassLoader.

• RunnableAdapter

RunnableAdapter类比较简单，给定运行的任务和结果，运行给定的任务并返回给定的结果，源代码如下所示.

1. /**
2. * A callable that runs given task and returns given result
3. */
4. static final class RunnableAdapter implements Callable {
5. final Runnable task;
6. final T result;
7. RunnableAdapter(Runnable task, T result) {
8. this.task = task;
9. this.result = result;
10. }
11. public T call() {
12. task.run();
13. return result;
14. }
15. }

• TaskCallable

TaskCallable类是javafx.concurrent.Task类的静态内部类，TaskCallable类主要是实现了Callable接口并且被定义为FutureTask的类，并且在这个类中允许我们拦截call()方法来更新task任务的状态。源代码如下所示.

1. private static final class TaskCallable implements Callable {
2.  
3. private Task task;
4. private TaskCallable() { }
5.  
6. @Override
7. public V call() throws Exception {
8. task.started = true;
9. task.runLater(() -> {
10. task.setState(State.SCHEDULED);
11. task.setState(State.RUNNING);
12. });
13. try {
14. final V result = task.call();
15. if (!task.isCancelled()) {
16. task.runLater(() -> {
17. task.updateValue(result);
18. task.setState(State.SUCCEEDED);
19. });
20. return result;
21. } else {
22. return null;
23. }
24. } catch (final Throwable th) {
25. task.runLater(() -> {
26. task._setException(th);
27. task.setState(State.FAILED);
28. });
29. if (th instanceof Exception) {
30. throw (Exception) th;
31. } else {
32. throw new Exception(th);
33. }
34. }
35. }
36. }

从TaskCallable类的源代码可以看出，只定义了一个Task类型的成员变量。下面主要分析TaskCallable类的call()方法.

当程序的执行进入到call()方法时，首先将task对象的started属性设置为true，表示任务已经开始，并且将任务的状态依次设置为State.SCHEDULED和State.RUNNING，依次触发任务的调度事件和运行事件。如下所示.

1. task.started = true;
2. task.runLater(() -> {
3. task.setState(State.SCHEDULED);
4. task.setState(State.RUNNING);
5. });

接下来，在try代码块中执行Task对象的call()方法，返回泛型对象。如果任务没有被取消，则更新任务的缓存，将调用call()方法返回的泛型对象绑定到Task对象中的ObjectProperty对象中，其中，ObjectProperty在Task类中的定义如下.

1. private final ObjectProperty value = new SimpleObjectProperty<>(this, "value");

接下来，将任务的状态设置为成功状态。如下所示.

1. try {
2. final V result = task.call();
3. if (!task.isCancelled()) {
4. task.runLater(() -> {
5. task.updateValue(result);
6. task.setState(State.SUCCEEDED);
7. });
8. return result;
9. } else {
10. return null;
11. }
12. }

如果程序抛出了异常或者错误，会进入catch()代码块，设置Task对象的Exception信息并将状态设置为State.FAILED，也就是将任务标记为失败。接下来，判断异常或错误的类型，如果是Exception类型的异常，则直接强转为Exception类型的异常并抛出。否则，将异常或者错误封装为Exception对象并抛出，如下所示.

1. catch (final Throwable th) {
2. task.runLater(() -> {
3. task._setException(th);
4. task.setState(State.FAILED);
5. });
6. if (th instanceof Exception) {
7. throw (Exception) th;
8. } else {
9. throw new Exception(th);
10. }
11. }

好了，今天就到这儿吧，大家学会了吗?我是冰河，我们下期见~~ 。

原文链接：https://mp.weixin.qq.com/s/JeSHgs8DvfiHhyTBOaLEYw 。

最后此篇关于一个 Callable 接口能有多少知识点？的文章就讲到这里了,如果你想了解更多关于一个 Callable 接口能有多少知识点？的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。