JAVA版Future模式实现代码

JAVA版Future模式实现代码

思路：

1、调用方发送数据给被调用方并起一个线程等待数据填充，

2、被调用方立马返回数据并启动一个线程处理，

3、处理完把数据交给调用方并唤醒调用方线程。

调用方代码：

import java.util.concurrent.locks.ReentrantLock;

/**
* @author 作者：hui E-mail: 137437006@qq.com
* @version 创建时间：2018年1月12日 下午5:11:46
* 类说明
*/
public class FutureClient {

public String futureMsg;

public String sendMsg;

public ReentrantLock lock = new ReentrantLock();

public FutureServer futureServer = new FutureServer();

public void sendMsg(){
this.sendMsg = "客户端发送数据";
System.out.println("客户端发送数据");
futureServer.acceptMsg(this);
System.out.println("已经发送了异步数据，下一步获取异步数据");
getFutureMsg();
System.out.println("客户端任务结束，做其他事情……");
}

public void getFutureMsg(){
new Thread(){
@Override
public void run() {
try {
synchronized (lock) {
lock.wait();
}
System.out.println("客户端接收到数据了:"+futureMsg);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
}

public static void main(String[] args) {
FutureClient client = new FutureClient();
client.sendMsg();
}
}

被调用方代码：

/**
* @author 作者：hui E-mail: 137437006@qq.com
* @version 创建时间：2018年1月12日 下午5:11:28
* 类说明
*/
public class FutureServer {

private FutureClient futureClient;

public void acceptMsg(FutureClient futureClient){
this.futureClient = futureClient;
System.out.println("服务器收到数据："+futureClient.sendMsg);
new Thread(){
@Override
public void run() {
try {
Thread.sleep(5000);
futureClient.futureMsg = "服务器异步数据返回";
synchronized (futureClient.lock) {
futureClient.lock.notify();
}
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}.start();
return;
}
}

看了一下别人的future模式，把锁放在服务器端会更为合理一些！所以，改进版本：

Client:

/**
* @author 作者：hui E-mail: 137437006@qq.com
* @version 创建时间：2018年1月18日
* 类说明
*/
public class FutureClient2 {

public String futureMsg;

public String sendMsg;

public FutureServer2 futureServer = new FutureServer2();

public void sendMsg(){
this.sendMsg = "客户端发送数据";
System.out.println("客户端发送数据");
futureServer.acceptMsg(this);
System.out.println("已经发送了异步数据，下一步获取异步数据");
System.out.println("客户端主线任务结束，做其他事情……");
}

public void getFutureMsg(){
new Thread(){
@Override
public void run() {
futureMsg = futureServer.getMsg();
System.out.println("客户端获取数据："+futureMsg);
}
}.start();
}

public static void main(String[] args) {
FutureClient2 client = new FutureClient2();
client.sendMsg();
client.getFutureMsg();
}
}

Service:

/**
* @author 作者：hui E-mail: 137437006@qq.com
* @version 创建时间：2018年1月18日
* 类说明
*/
public class FutureServer2 {

private FutureClient2 futureClient;

private String data;

private Boolean b = false;

public void acceptMsg(FutureClient2 futureClient){
this.futureClient = futureClient;
System.out.println("服务器收到数据："+futureClient.sendMsg);
new Thread(){
@Override
public void run() {
try {
Thread.sleep(5000);
data = "服务器异步数据返回";
synchronized (futureClient) {
b = true;
futureClient.notify();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
return;
}

public String getMsg(){
synchronized (futureClient) {
if(!b){
try {
futureClient.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
return data;
}
}

使用JDK内置的Future模式的接口实现Future,让我更深入的了解了future模式

1、要利用FutureTask来完成的任务，实现Callable接口重写call方法；

2、服务端接收任务利用线程池来完成具体的任务；

3、客户端开启新线程来提取任务结果。

FutureTask源码阅读与理解传送门

client-callable:

import java.util.concurrent.Callable;

public class CallableTask implements Callable<String> {
@Overri
b901
de
public String call() throws Exception {
Thread.sleep(5000);
return "Callable执行完毕";
}
}

client:

/**
* @author 作者：hui E-mail: 137437006@qq.com
* @version 创建时间：2018年1月18日
* 类说明
*/
public class FutureClient3 {

public String futureMsg;

public String sendMsg;

public FutureWoker futureServer = new FutureWoker();

public void sendMsg(){
this.sendMsg = "客户端发送数据";
System.out.println("客户端发送数据");
futureServer.sendMsg(new CallableTask());
System.out.println("已经发送了异步数据，等待FutureWork工作完毕并获取异步数据");
System.out.println("客户端主线任务结束，做其他事情……");
}

public void getFutureMsg(){
new Thread(){
@Override
public void run() {
try {
System.out.println("客户端获取数据："+futureServer.getMsg());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}.start();
}

public static void main(String[] args) {
FutureClient3 client = new FutureClient3();
client.sendMsg();
client.getFutureMsg();
}
}

futurework:

/**
* @author 作者：hui E-mail: 137437006@qq.com
* @version 创建时间：2018年1月18日
* 类说明
*/
public class FutureWoker {

FutureTask<String> f = null;

ExecutorService executor = Executors.newSingleThreadExecutor();

public String sendMsg(Callable<String> call){
System.out.println("异步线程开始调用");
f = new FutureTask<>(call);
executor.execute(f);
return "TRUE";
}

public String getMsg() throws Exception{
String string = f.get();
executor.shutdown();
return string;
}
}