并发程序设计之Future模式

一)、使用Future模式的原因

当某一段程序提交了一个请求,期待得到一个答复,但服务程序对这个请求的处理可能很慢,在单线程的环境中,调用函数是同步的,必须等到服务程序返回结果后才能进行其他处理,在这段时间里,客户端一直处于等待状态。

二)、Future模式

使用并发的设计思想,解决客户端发送请求到应用程序,等待响应数据时间过长的问题.

三)、Future模式的核心结构

1.main: 系统启动类

作用:调用Client,发送请求。

2.client: 发送请求类

 作用:返回Data对象,即FutureData对象,并开启一个线程给返回的FutureData对象装配RealData。

3.Data:数据接口

 作用:FutureData和RealData共同实现了这个接口。

4.FutureData: 虚假数据类

 作用:Future数据,构造快,虚假数据,装配RealData对象,相当于RealData的一个代理。

5.RealData: 真实数据类

   作用:返回服务程序处理的真实数据。

四)、Future模式的实现流程

1).用户发送client请求服务到应用程序,先返回一个虚假的数据FutureData类,并启一个新的线程,用于装配真正的数据返回对象。

2).提供一个接口类Data,类中提供一个接口方法,虚假类FutureData和真实类RealData分别实现对应的接口方法。

  1. .将新的线程装配成功的RealData对象加入FutureData中,FutureData相当于RealData的代理对象,在接口方法中调用RealData,的到应用程序真实的响应数据。

五)、Future模式的简单复现

模拟用户在淘宝购买商品的场景:

购买香水,用户购买商品后返回一个商品订单(相当于FutureData),并没有马上返回商品,用户需等待物流才能获得商品在等待物流派送的这段时间用户可以做其他事情(用户执行其他的业务逻辑),当货物到达再取货。当用户想要取货时,可以通过物流信息来监控货物是否到达(状态值isReady),若物流状态为未到达,用户不可取货,只能等待,当物流到达,用户取货(result())。

系统启动类:ClientService

/**
* 系统启动类
*/
public class ClientService {
public static void main(String[] args) {
//调用Client,发送请求
Client client = new Client();
//得到一个FutureData对象
Data data = client.request("channel香水 x 1:购买");
System.out.println("我在执行其他的业务");
//模拟客户端发送请请求后,继续执行其他的业务逻辑
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//用户的到真实的数据对象
System.out.println(data.result());
}
}

客户端请求类:Client

public class Client {
/**
* 客户端发送请求后,先返回一个FutureData,并开启一个线程,装配一个RealData到返回的FutureData中
*
*/
public Data request(String requestStr){
//创建一个Future对象
FutureData future = new FutureData();
//开启一个线程,创建RealData对象,并将该对象装配到future中
new Thread(){
@Override
public void run(){
//创建RealData对象
RealData realData = new RealData(requestStr);
//装配realData对象到future中
future.setRealData(realData);
}
}.start();
//用户请求后立即返回一个FutureData对象,执行其它的业务逻辑
return future;
}
}

接口类:Data

/**
* FutureData和RealData的共同接口
*/
public interface Data {
String result();
}

虚假数据类:FutureData

该类需要使用到线程的唤醒机制

1).使用isReady来监控对象是否被注入,isReady = false,对象未注入,线程请求

    request(),使用wait()让线程进入等待状态。
  1. .isReady = true,注入对象,使用notifyAll()唤醒等待线程。

原因: RealData的方法构造很慢,当调用FutureData的result()来获取真实数据

          时,RealData对象未被注入,因为FutureData的result()是调用了RealData

          的的result()方法,此时,对象未注入,抛出NullPointException。

注:wait()和notify()/notifyAll要配合synchonized使用。

/**
* 该类需要使用到线程的唤醒机制:
* 使用isReady来监控对象是否被注入,isReady = false,对象未注 入,线程请求request(),使用wait()让线程进入等待状态
* isReady = true,注入对象,使用notifyAll()唤醒等待线程。
*
* 原因: RealData的方法构造很慢,当调用FutureData的result()来获取真实数据时,RealData对象未被注入,因为FutureData的result()
* 是调用了RealData的result()方法,此时,对象未注入,抛出NullPointException。
*/
public class FutureData implements Data {
/**
* 装配对象
*/
RealData realData = null; /**
* 装配标识符,监控装配对象是否成功注入
*/
Boolean isReady = false; /**
* 注入RealData
* @return
*/
public synchronized void setRealData(RealData realData){
if(isReady){
return;
}
this.realData = realData;
//注入对象后,将isReady设置为true
isReady = true;
//唤醒等待的线程
notifyAll();
} /**
* 实际上使用RealData获取真实的数据并返回结果
* @return
*/
@Override
public synchronized String result() {
//当对象未被注入时,等待对象的注入
if(!isReady){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return realData.result();
}
}

真实数据类:RealData

/**
* 真正的数据返回类
*/
public class RealData implements Data{
private String requestStr; /**
* 模拟在构造RealData对象时要花费很多时间
*/
public RealData(String requestStr) {
StringBuffer sb = new StringBuffer();
for(int i = 0; i < 100; i++){
sb.append(requestStr);
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} @Override
public String result() {
return "亲~ ,您的货物已经到件了哦!";
}
}

结果:

我在执行其他的业务
亲~ ,您的货物已经到件了哦!

六)、JDK内置实现

JDK提供了一个FutureTask和Callable接口来实现程序的异步操作。

1)、FutureTask类:

定义: 是一个线程类,能做为一个单独的线程运行。

1.实现RunableFuture接口

2.RunableFuture 继承了Runable、Future两个接口

2)、主要属性:

private Callable<V> callable;
//call()方法的返回值
private Object outcome;
//call()方法的执行状态
private volatile int state;
//新创建状态
private static final int NEW = 0;
//完成状态
private static final int COMPLETING = 1;
//标准状态
private static final int NORMAL = 2;
//异常状态
private static final int EXCEPTIONAL = 3;
//取消状态
private static final int CANCELLED = 4;
//正在中断状态
private static final int INTERRUPTING = 5;
//中断状态
private static final int INTERRUPTED = 6;

3)、构造方法new FutureTask(Callable callable) :

接收一个Callable类型的对象

public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}

4)、Callable接口:接口提供了一个call()方法。

在FutureTask的run()方法中会调用这个方法。call()方法中实现并发线程的主要逻辑。

public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}

5)、FutureTask的run()方法

实现逻辑:

1.调用Callable的call()方法,并获取其返回值。

2.将返回值赋值给outcome对象。

3.设置state状态值 state = NORMAL = 2。

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 {
//调用call()方法,并获取返回值
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);
}
} //将返回值赋值给outcome变量
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}

6)、FutureTask的get()方法

1).判断call()方法的状态。

2).若sate <=COMPLETING = 2,线程会进入等待状态。

3).相反,则返回outcome值,即call()方法的返回值。

public V get() throws InterruptedException, ExecutionException {
int s = state;
//判断call()方法的执行状态,判断是否进入等待状态
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
} //返回outcome的值
private V report(int s) throws ExecutionException {
Object x = outcome;
if (s == NORMAL)
return (V)x;
if (s >= CANCELLED)
throw new CancellationException();
throw new ExecutionException((Throwable)x);
}

7)、使用JDK自带的Future模式复现商品购买场景:

系统启动类:

/**
* 模拟淘宝下单:
* 购买香水,用户购买商品后返回一个商品订单,并没有马上返回商品,用户需 * 等待物流才能获得商品在等待物流派送的这段时间用户可以做其他事情,当货 * 物到达再取货。当用户想要取货时,可以通过物流信息来监控货物是否到达, * 若物流状态为未到达,用户不可取货,只能等待。
*/
public class JDK_ClientService {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//创建一个FutureTask对象,相当于上文FutureData,该对象是一个线程类
FutureTask future = new FutureTask(new RealData("chanta(nel香水 x 1: 购买!"));
//创将线程池执行器,返回一个ThreadPool对象
ExecutorService executor = Executors.newFixedThreadPool(1);
//开启线程,发送请求,执行future线程的run()方法,执行请求的具体逻辑
executor.submit(future);
System.out.println("我要去执行其他业务了");
//模拟程序执行其它逻辑
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//得到请求的真实返回数据,get方法会判断监控call()的状态,当call()的状态未执行或未执行完毕,线程进入等待状态。
System.out.println(future.get());
} }

真实类:实现Callabel接口,复写call()方法,定义Run方法的具体逻辑

public class RealData implements Callable {
private String requestStr;
/**
* 轻量级的构造方法
*/
public RealData(String requestStr) {
this.requestStr = requestStr;
} /**
* 将复杂的业务逻辑都放在call方法中
* @return
* @throws Exception
*/
@Override
public Object call(){
StringBuffer sb = new StringBuffer();
for(int i = 0; i < 10; i++){
sb.append(requestStr);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//指定FutureTask的返回对象
return "亲~, 您的香水已到货!";
}
}

结果:

我要去执行其他业务了
亲~, 您的香水已到货!

结论:

Jdk中Future模式的实现主要是依赖Callable接口,FutureTask类。

首先,在创建FutureTask对象的时候传入一个Callable的子类对象,获取线程池执行器,通过线程池执行器来开启FutureTask的线程,执行run()方法,在run()方法中调用Callable的子类对象的call()方法,并使用一个outcome变量来存储call()方法的返回值,使用一个int类型的变量state来监控call()方法的执行情况,用户可以通过get()方法来获取call()方法的返回值,get()方法根据state值来决定程序是否进入等待状态,若state = normal = 2 = 正常值,返回call()的返回结果。

Future模式的学习以及JDK内置Future模式的源码分析的更多相关文章

  1. Java并发包源码学习之AQS框架(四)AbstractQueuedSynchronizer源码分析

    经过前面几篇文章的铺垫,今天我们终于要看看AQS的庐山真面目了,建议第一次看AbstractQueuedSynchronizer 类源码的朋友可以先看下我前面几篇文章: <Java并发包源码学习 ...

  2. Springboot学习04-默认错误页面加载机制源码分析

    Springboot学习04-默认错误页面加载机制源码分析 前沿 希望通过本文的学习,对错误页面的加载机制有这更神的理解 正文 1-Springboot错误页面展示 2-Springboot默认错误处 ...

  3. 2018.11.20 Struts2中对结果处理方式分析&struts2内置的方式底层源码剖析

    介绍一下struts2内置帮我们封装好的处理结果方式也就是底层源码分析 这是我们的jar包里面找的位置目录 打开往下拉看到result-type节点 name那一列就是我们的type类型取值 上一篇博 ...

  4. JDK(五)JDK1.8源码分析【集合】HashMap

    本文转载自无始无终,原文连接 HashMap 在 JDK 1.8 后新增的红黑树结构 传统 HashMap 的缺点 JDK 1.8 以前 HashMap 的实现是 数组+链表,即使哈希函数取得再好,也 ...

  5. java内置线程池ThreadPoolExecutor源码学习记录

    背景 公司业务性能优化,使用java自带的Executors.newFixedThreadPool()方法生成线程池.但是其内部定义的LinkedBlockingQueue容量是Integer.MAX ...

  6. JDK(二)JDK1.8源码分析【排序】timsort

    如无特殊说明,文中的代码均是JDK 1.8版本. 在JDK集合框架中描述过,JDK存储一组Object的集合框架是Collection.而针对Collection框架的一组操作集合体是Collecti ...

  7. Java并发包源码学习之线程池(一)ThreadPoolExecutor源码分析

    Java中使用线程池技术一般都是使用Executors这个工厂类,它提供了非常简单方法来创建各种类型的线程池: public static ExecutorService newFixedThread ...

  8. JDK(七)JDK1.8源码分析【集合】TreeMap

    本文转载自joemsu,原文链接 [JDK1.8]JDK1.8集合源码阅读——TreeMap(二) TreeMap是JDK中一种排序的数据结构.在这一篇里,我们将分析TreeMap的数据结构,深入理解 ...

  9. JDK(三)JDK1.8源码分析【排序】mergeSort

    归并排序是JDK对象数组的排序算法之一,接下来开始分析JDK的归并排序算法. /** * 将指定范围的对象数组按自然顺序升序排序 * * Src is the source array that st ...

随机推荐

  1. lambda高级查询

    1.什么是lambda表达式:Lambda 表达式,是一种简化的匿名函数,可用于创建委托或表达式目录树.其次,也可以将 Lambda 表达式作为参数进行传递,或者将它作用于函数调用值调用后返回的一个函 ...

  2. Redis备忘(一)

    hash: 渐进式rehash:同时查询新旧两个hash,然后在后续定时任务以及hash的子指令中,循序渐进将旧的迁移到新的hash表 Redis应用: 1.分布式锁: 实现1:setnx+expir ...

  3. StackView在Android的应用

    StackView是AdapterViewAnimator的子类,它用于显示Adapter提供的一系列View.StackView将会以“堆叠”的方式来显示多个列表项.为了控制StackView现实的 ...

  4. js控制进度条数据

    <style><!-- #time{ width:500px; height: 20px; background: red; border-radius: 10px; } --> ...

  5. rem1

    <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <meta name ...

  6. fenby C语言 P26

    指针 地址 类型+“*”+变量名=指针变量 int *p1;//指向整型变量的指针变量p1 float *p2;//指向浮点型变量的指针变量p2 char *p3;//指向字符型变量的指针变量p3 “ ...

  7. 学习笔记11全局处理程序global.asax

    *全局处理程序Clobal.asax只能叫这个名字,不能修改文件名,如果网站没有的话,可以自己添加. *Application[]类似于session,是全局的,Application["k ...

  8. OV5640摄像头的数据处理配置流程(一)

    module RGB_init( //系统信号输入(时钟+复位) input cmos_clk_i, //模块控制时钟 input rst_n_i, //系统复位信号 //OV5640输出信号(从56 ...

  9. Java基本数据类型的传值

    传递值: 说明:标题其实说法是错误的.Java中只有值传递,没有引用传递. ... ... //定义了一个改变参数值的函数 public static void changeValue(int x) ...

  10. [考试反思]1105csp-s模拟测试102: 贪婪

    还是有点蠢... 多测没清空T3挂40...(只得了人口普查分20) 多测题要把样例复制粘两遍自测一下防止未清空出锅. 然而不算分... 其实到现在了算不算也不重要了吧... 而且其实T3只考虑最长路 ...