多线程——11Future模式

Future产生起源

• 在以前我们写的多线程执行任务是拿不到多线程的执行结果的，除非我们使用前面咱们说的观察者模式来获取； 在这里我们提供能外一种方式来获取线程的执行结果

三个重要角色

• Future他是保存任务调用之后的结果，在他里面需要提供get方法让主线程去拿到结果， 也要提供设置方法让直行线程去设置结果； 如果执行未完成就调用泛型返回值的wait方法阻塞主线程，当执行线程调用了设置方法时调用notifyall进行通知
• FutureTask里面主要是call方法，这个方法用于执行任务，并且放回结果为实际想要的的结果
• FutureService他主要是提供一个方法让主线程去提交任务，提交后他来负责监控执行线程结果的设置

具体代码

• Future接口定义,

public interface Future<T> {
    T get() throws InterruptedException;
    void set(T res);
}

• 异步任务Future实现

public class AsyncFuture<T> implements Future<T> {

    private volatile boolean done = false;
    private T res;

    @Override
    public T get() throws InterruptedException {
        synchronized (this) {
            while (!done) {
                this.wait();
            }
        }
        return res;
    }

    @Override
    public void set(T res) {
        synchronized (this) {
            this.res = res;
            this.done = true;
            this.notifyAll();
        }
    }
}

• FutureTask接口

public interface FutureTask<T> {
    T call();
}

• FutureService实现

public class FutureService {


    /**
     * 询问方式
     * @param task
     * @param <T>
     * @return
     */
    public <T> Future<T> submit(FutureTask<T> task) {
        Future<T> future = new AsyncFuture<T>();
        new Thread(() -> {
            T call = task.call();
            future.set(call);
        }).start();
        return future;
    }


    /**
     * 回调方式
     * @param task
     * @param <T>
     * @return
     */
    public <T> Future<T> submitByCallBack(FutureTask<T> task, Consumer<T> consumer) {
        Future<T> future = new AsyncFuture<T>();
        new Thread(() -> {
            T call = task.call();
            future.set(call);
            consumer.accept(call);
        }).start();
        return future;
    }
}