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 synchronized 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=蛋糕]