我们都知道Callable接口作为任务给线程池来执行,可以通过Future对象来获取返回值,他们背后的实现原理是什么?通过总结背后的实现原理有助于我们深入的理解相关技术,做到触类旁通和举一反三。

文章目录

一、使用示例

先通过一个简单示例来了解Callable如何使用:

public class FutureTaskTest {
public static void main(String[] args) {
ExecutorService executor = Executors.newCachedThreadPool();
Task task = new Task();
Future<Integer> result = executor.submit(task);
executor.shutdown(); try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
} System.out.println("主线程在执行任务"); try {
System.out.println("task运行结果"+result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} System.out.println("所有任务执行完毕");
} static class Task implements Callable<Integer> { public Integer call() throws Exception {
System.out.println("子线程在进行计算");
Thread.sleep(30000);
int sum = 0;
for(int i=0;i<100;i++)
sum += i;
return sum;
}
} }

  

二、工作流程分析

通过调试代码可知Callable工作流程如下:
1.submit方法接受Callable接口,首先包裹成功FutureTask对象,并作为返回值返回。
2.调用ThreadPoolExecutor.execute方法
2.1 线程池中的工作线程最终执行后会调用FutureTask的run方法。

public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}

2.2 run方法主要是执行Callable接口,并把返回值写入到FutureTask的outcome属性中,并调用LockSupport.unpack方法
3.主线程继续执行。
4.主线程调用FutureTask.get方法获取返回值。
4.1 如果FutureTask计算没有完成,那么需要等待完成,这个时候会调用LockSupport.pack方法阻塞线程

    private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
} int s = state;
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
else if (q == null)
q = new WaitNode();
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
else
LockSupport.park(this);
}
}

三、工作流程归纳

Callable工作流程归纳:
1.submit方法接受Callable接口,首先包裹成功futruetask对象,并作为返回值返回。
2.FutureTask实现了Runnable接口和Future接口。由于实现了Runnable接口(runnable实现方法中会调用Callable接口),可以给线程池执行;future接口管理执行过程,比方说取消,阻塞获取执行结果,判断是否执行完成,是否取消。

所以Callable接口实现的核心是FutureTask,那么FutureTask类的设计原理是什么呢?

四、FutureTask类的设计原理

要理解一个类的设计原理,首先要知道这个类为我们提供了什么功能。通过上面的流程归纳2我们知道,FutureTask给我们提供两个功能?

  • 作为一个任务,可以给线程池来执行。
  • 能够任务做一些控制:比方说取消,阻塞获取执行结果,判断是否执行完成,是否取消

这里我们重点分析下阻塞获取执行结果必要性和实现思路。

必要性:

如果我们一个后端接口有一些耗时(CPU/IO)的操作需要执行,我们首先能想到的方法是把这些操作并行处理。任务并行处理之后,就有一个线程同步的问题:主线程执行完其他操作后,可能需要获取其他线程的执行结果。如果并行操作还没有完成,主线程需要等待并行操作完成后,才能拿到最终结果。所以Future.get方法是有必要的。

实现思路:

  • FutureTask依赖一个Callable接口,这个接口表示具体需要执行的任务。
  • 实现Runnable接口,这样就可以交给线程池来实现。
  • Runnable接口实现方法中主要做的事情是调用Callable接口完成计算任务,并把结果集返回一个变量中,并更新任务状态。
  • FutureTask.get方法,根据任务状态来判断任务是否完成,如果没有完成需要等待任务的完成,完成挂起线程。
  • Runnable接口中的任务完成后,会唤醒主线程。
  • 主线程继续执行,能获取结果。

Callable Future接口的设计原理的更多相关文章

  1. Callable接口、Runable接口、Future接口

    1. Callable与Runable区别 Java从发布的第一个版本开始就可以很方便地编写多线程的应用程序,并在设计中引入异步处理.Thread类.Runnable接口和Java内存管理模型使得多线 ...

  2. Java Callable接口、Runable接口、Future接口

    1. Callable与Runable区别 Java从发布的第一个版本开始就可以很方便地编写多线程的应用程序,并在设计中引入异步处理.Thread类.Runnable接口和Java内存管理模型使得多线 ...

  3. Future接口和Callable接口以及FeatureTask详解

    类继承关系 Callable接口 @FunctionalInterface public interface Callable<V> { V call() throws Exception ...

  4. Java Callable接口与Future接口的两种使用方式

    Java Callable.Future的两种使用方式Callable+Futurepublic class Test { public static void main(String[] args) ...

  5. 使用Callable和Future接口创建线程

    具体是创建Callable接口的实现类,并实现clall()方法.并使用FutureTask类来包装Callable实现类的对象,且以此FutureTask对象作为Thread对象的target来创建 ...

  6. Atitit.面向接口的web 原理与设计重写 路由启动绑定配置url router rewriting urlpage  mvc mvp的 java c#.net php js

    Atitit.面向接口的web 原理与设计重写 路由启动绑定配置url router rewriting urlpage  mvc mvp的 java c#.net php js 原理 通过vm带入启 ...

  7. Future接口和FutureTask类【FutureTask实现了Runnable和Future接口】

    Future API: public interface Future<V> { /** * Attempts to cancel execution of this task. This ...

  8. java笔记--用ThreadLocal管理线程,Callable<V>接口实现有返回值的线程

    用ThreadLocal管理线程,Callable<V>接口实现有返回值的线程 ThreadLocal在我的笔记"关于线程同步"的第5种方式里面有介绍,这里就不多说了. ...

  9. BigPipe设计原理

    高性能页面加载技术--BigPipe设计原理及Java简单实现 1.技术背景 动态web网站的历史可以追溯到万维网初期,相比于静态网站,动态网站提供了强大的可交互功能.经过几十年的发展,动态网站在互动 ...

随机推荐

  1. eShopOnContainers 看微服务③:Identity Service

    引言 通常,服务所公开的资源和 API 必须仅限受信任的特定用户和客户端访问.那进行 API 级别信任决策的第一步就是身份认证——确定用户身份是否可靠. 在微服务场景中,身份认证通常统一处理.一般有两 ...

  2. 全球DDOS安全防护

    转:http://www.safecdn.cn/ https://www.safeidc.cn/llqx.html 全球可视化的DDoS攻击地图:Digital Attack Map 这个项目是源于G ...

  3. 设计一函数,求整数区间[a,b]和[c,d]的交集

    问题: 设计一函数,求整数区间[a,b]和[c,d]的交集.(c/c++.Java.Javascript.C#.Python)  1.Python: def calcMixed(a,b,c,d): r ...

  4. Python第6天

    主要内容: 递归:函数在内部自己调用自己,它的作用域没有return默认返回none 匿名函数 lambda ,与def的区别在于def可自行处理成元组,而lambda不行, func = lambd ...

  5. cached_property的使用

    cached_property修饰过的函数,变成是对象的属性,该对象第一次引用该属性时,会调用函数,对象第二次引用该属性时就直接从词典中取了,这也说明引用属性是经过__getattritue__. c ...

  6. endnote将参考文献导入word中

    在endnote中将目标文献选中 然后返回word 将光标放到目标位置 个人网盘,endnoteX7资源 链接:https://pan.baidu.com/s/1lEocicehiPm1Ypkw768 ...

  7. JS防抖与节流函数封装

    防抖 在监听scroll事件的时候经常会用到防抖,当滚动到某一位置而触发状态,从而不会出现频繁滚动持续触发事件的情况 防抖的事件处理机制仅触发一次且必须是结束状态下才会执行 function debo ...

  8. v-for key

    key 当 Vue.js 用 v-for 正在更新已渲染过的元素列表时,它默认用“就地复用”策略.如果数据项的顺序被改变,Vue 将不会移动 DOM 元素来匹配数据项的顺序, 而是简单复用此处每个元素 ...

  9. 发现一个好工具RenderDoc

    逛VULKAN官网时,工具中提到RenderDoc这个东西,百度了下,是专为图形程序员用的,可以集成到VS,或U3D中,收藏先. 参考链接

  10. c++常见变量的极值

    #include "numeric_limits.hpp"#include <limits>#include <iostream> //////////// ...