写点什么

【高并发】深入解析 Callable 接口

作者:冰河
  • 2022 年 2 月 16 日
  • 本文字数:5856 字

    阅读完需:约 19 分钟

【高并发】深入解析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 的表面工作,理解并掌握底层原理并熟悉源码实现,并形成自己的抽象思维能力,做到灵活运用,才是你突破瓶颈,脱颖而出的重要方向!


最后,作为一名合格(发际线比较高)的开发人员或者资深(秃顶)的工程师和架构师来说,理解原理和掌握源码,并形成自己的抽象思维能力,灵活运用是你必须掌握的技能。


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

发布于: 2022 年 02 月 16 日阅读数: 102
用户头像

冰河

关注

公众号:冰河技术 2020.05.29 加入

互联网资深技术专家,《深入理解分布式事务:原理与实战》,《海量数据处理与大数据技术实战》和《MySQL技术大全:开发、优化与运维实战》作者,mykit-data与mykit-transaction-message框架作者。【冰河技术】作者。

评论

发布
暂无评论
【高并发】深入解析Callable接口_Java_冰河_InfoQ写作社区