并发编程之Future模式的模拟实现

Future模式的核心就是，使原本需要等待的时间段可以用于处理其他业务逻辑。记住这句话就行了。

先来看一个Future的案列：

/**
* future的使用
* @author 莱格
*
*/

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FutureDemo {

public static void main(String[] args) throws InterruptedException, ExecutionException {
//假设这里在计算一个结果要花5秒钟，我们就可以起一个线程让他计算，在计算期间我们可以干别的事情。
Callable<Integer> call = new Callable<Integer>() {
public Integer call() throws Exception {
System.out.println("正在计算结果");
Thread.sleep(5000);
return 1;
};
};
//把call交给FutureTask
FutureTask<Integer> task = new FutureTask<>(call);
//开启线程去执行计算任务
Thread t = new Thread(task);
t.start();
//在这期间，我们可以干点别的
Thread.sleep(10);
System.out.println("干点别的");
//干完之后，等计算完成，在爱拿到结果
Integer result = task.get();
System.out.println("拿到的结果为："+result);
}
}

下面，我们模拟一个场景，实现Future模式。

假设，现在你要去面包店去买一块蛋糕，但是，生产一块蛋糕要花一段时间，你总不能一直等下去，这个时候，你可以先去上班，等下班回来之后，你再去取蛋糕。

我们就实现这么一个场景。

import java.util.Random;

/**
* Future的手写实现：
* 思路分析：
* 1、创建一个产品
* 2、创建一个工厂，通过工厂创建订单，通过订单可以拿到商品。
* 3、在创建订单的时候，需要另起一个线程去执行生产商品。
* 4、这样顾客就可以去干别的，比如去上班，上班回来之后就可以拿到之前生产的商品了。
*
*
* @author 莱格
*
*/
public class FutureImpl {
public static void main(String[] args) {
ProductFactory pf = new ProductFactory();
Future f = pf.createProduct("蛋糕");
System.out.println("我去上班啦，下了班我来取蛋糕！");
//拿着订单取产品
try {
Thread.sleep(8000);
System.out.println("老板，蛋糕做好了吗？");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
Thread.sleep(1000);
System.out.println("老板：做好了，你去拿一下");
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("谢谢老板，那我走了，我的蛋糕是：" + f.getProduct());
}
}

class Product {
private int id;
private String name;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Override
public String toString() {
return "Product [id=" + id + ", name=" + name + "]";
}

public Product() {
super();
// TODO Auto-generated constructor stub
}

public Product(int id, String name) {

try {
System.out.println("开始生产" + name);
Thread.sleep(4000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.id = id;
this.name = name;
System.out.println(name + "生产完毕！");
}
}

class ProductFactory{
public Future createProduct(String name) {
System.out.println("下单成功，你可以去上班了");
//生产产品，返回订单
//创建一个订单
Future f = new Future();
new Thread(() ->{
Product p = new Product(new Random().nextInt(),name);
//通过订单取产品
f.setProduct(p);
}).start();
return f;
}
}

class Future{
private Product product;
private boolean down;
public synchro
4000
nized Product getProduct() {

while (!down) {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return product;

}

public synchronized void setProduct(Product product) {
if (down) {
return;
}

this.product = product;
this.down = true;
notifyAll();
}

}

运行结果：

下单成功，你可以去上班了
我去上班啦，下了班我来取蛋糕！
开始生产蛋糕
蛋糕生产完毕！
老板，蛋糕做好了吗？
老板：做好了，你去拿一下
谢谢老板，那我走了，我的蛋糕是：Product [id=432193397, name=蛋糕]