文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

一个 Callable 接口能有多少知识点？

2024-12-02 09:43

关注

并发编程一直是程序员们比较头疼的，如何编写正确的并发程序相比其他程序来说，是一件比较困难的事情，并发编程中出现的 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类是Callable接口的一个特殊实现类，它表明Callable对象有某种特权来访问系统的某种资源，PrivilegedCallable类的源代码如下所示。

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

从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()方法来执行最终的业务逻辑，并且返回泛型对象。

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

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

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

  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类比较简单，给定运行的任务和结果，运行给定的任务并返回给定的结果，源代码如下所示。

  1.  
  2. static final class RunnableAdapter implements Callable { 
  3.  final Runnable task; 
  4.  final T result; 
  5.  RunnableAdapter(Runnable task, T result) { 
  6.   this.task = task; 
  7.   this.result = result; 
  8.  } 
  9.  public T call() { 
  10.   task.run(); 
  11.   return result; 
  12.  } 
  13. } 

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. } 

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

本文转载自微信公众号「冰河技术」，可以通过以下二维码关注。转载本文请联系冰河技术公众号。

 

来源：冰河技术内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

一个 Callable 接口能有多少知识点？

后端开发接口Callable2024-12-02

Springboot如何动态注册处理请求接口？这个知识点你值得了解一下

后端开发springboot2024-12-03
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯