一个Callable接口能有多少知识点？在裁员的大背景下，我仍然吊打了大厂面试官

大家好，我是冰河~~

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

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

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

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

Callable接口介绍

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

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}
1
2
3
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类的源代码如下所示。

/**
 * 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();
  }
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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

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

private final Callable<T> task;
private final AccessControlContext acc;
1
2

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

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

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

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

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

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

private static native AccessControlContext getStackAccessControlContext();
1

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

接下来，我们回到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();
 }
}
1
2
3
4
5
6
7
8
9
10
11
12

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

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

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

可以看到，又是一个本地方法。也就是说，最终的执行情况是将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();
  }
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

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

private final Callable<T> task;
private final AccessControlContext acc;
private final ClassLoader ccl;
1
2
3

接下来，通过构造方法注入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();
}
1
2
3
4
5
6
7
8
9
10

接下来，通过调用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();
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在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;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 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);
   }
  }
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

从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);
});
1
2
3
4
5

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

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

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

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

如果程序抛出了异常或者错误，会进入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);
 }
}
1
2
3
4
5
6
7
8
9
10
11

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

写在最后

如果你想进大厂，想升职加薪，或者对自己现有的工作比较迷茫，都可以私信我交流，希望我的一些经历能够帮助到大家~~

推荐阅读：

• 《实践出真知：全网最强秒杀系统架构解密，不是所有的秒杀都是秒杀！！》
• 《从零到上亿用户，我是如何一步步优化MySQL数据库的？（建议收藏）》
• 《我用多线程进一步优化了亿级流量电商业务下的海量数据校对系统，性能再次提升了200%！！（全程干货，建议收藏）》
• 《我用多线程优化了亿级流量电商业务下的海量数据校对系统，性能直接提升了200%！！（全程干货，建议收藏）》
• 《我用10张图总结出了这份并发编程最佳学习路线！！（建议收藏）》
• 《高并发场景下一种比读写锁更快的锁，看完我彻底折服了！！（建议收藏）》
• 《全网最全性能优化总结！！（冰河吐血整理，建议收藏）》
• 《三天撸完了MyBatis，各位随便问！！（冰河吐血整理，建议收藏）》
• 《奉劝那些刚参加工作的学弟学妹们：要想进大厂，这些并发编程知识是你必须要掌握的！完整学习路线！！（建议收藏）》
• 《奉劝那些刚参加工作的学弟学妹们：要想进大厂，这些核心技能是你必须要掌握的！完整学习路线！！（建议收藏）》
• 《奉劝那些刚参加工作的学弟学妹们：这些计算机与操作系统基础知识越早知道越好！万字长文太顶了！！（建议收藏）》
• 《我用三天时间开发了一款老少皆宜的国民级游戏，支持播放音乐，现开放完整源代码和注释（建议收藏）！！》
• 《我是全网最硬核的高并发编程作者，CSDN最值得关注的博主，大家同意吗？（建议收藏）》
• 《毕业五年，从月薪3000到年薪百万，我掌握了哪些核心技能？（建议收藏）》
• 《我入侵了隔壁妹子的Wifi，发现。。。（全程实战干货，建议收藏）》
• 《千万不要轻易尝试“熊猫烧香”，这不，我后悔了！》
• 《清明节偷偷训练“熊猫烧香”，结果我的电脑为熊猫“献身了”！》
• 《7.3万字肝爆Java8新特性，我不信你能看完！（建议收藏）》
• 《在业务高峰期拔掉服务器电源是一种怎样的体验？》
• 《全网最全Linux命令总结！！（史上最全，建议收藏）》
• 《用Python写了个工具，完美破解了MySQL！！（建议收藏）》
• 《SimpleDateFormat类到底为啥不是线程安全的？（附六种解决方案，建议收藏）》
• 《MySQL 8中新增的这三大索引，直接让MySQL起飞了，你竟然还不知道！！（建议收藏）》
• 《撸完Spring源码，我开源了这个分布式缓存框架！！（建议收藏）》
• 《亿级流量高并发秒杀系统商品“超卖”了，只因使用的JDK同步容器中存在这两个巨大的坑！！（踩坑实录，建议收藏）》
• 《奉劝那些刚参加工作的学弟学妹们：要想学好并发编程，这些并发容器的坑是你必须要注意的！！（建议收藏）》
• 《公司的报表工具太难用，我三天撸了个Excel工具，运营小姐姐直呼太好用了，现已开源！！（建议收藏）》
• 《奉劝那些刚参加工作的学弟学妹们：要想进大厂，这些并发编程核心技能是你必须要掌握的！！（建议收藏）》
• 《阿里面试官：高并发大流量秒杀系统如何正确的解决库存超卖问题？（建议收藏）》
• 《Redis五大数据类型与使用场景汇总！！（含完整实战案例，建议收藏）》

好了，今天就到这儿吧，小伙伴们点赞、收藏、评论，一键三连走起呀，我是冰河，我们下期见~~