并发编程之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 call = new Callable() {
            public Integer call() throws Exception {
                System.out.println("正在计算结果");
                Thread.sleep(5000);
                return 1;
            };
        };
        //把call交给FutureTask
        FutureTask 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=蛋糕]