Java 高并发编程详解 9.0 Future(凭据)模式

Future模式

当一个任务任务执行时间很长，调用者正常会阻塞很久。为避免这种情况出现，可以先返回一个凭据给调用者。后面调用者通过这个凭据查看任务执行结果。异步非阻塞也是类似思想。

Future设计模式实现

1. future接口

/**
 * 提供 获取执行确认结果和判断是否执行完成
 */
public interface Future<T> {
    // 返回计算后结果 该方法会陷入阻塞状态
    T get() throws InterruptedException;
    // 判断任务是否已经被执行完成
    boolean done();
}

2. future接口实现类

/**
 * Future 接口的实现类
 * 增加finish方法 用来接收任务被完成的通知 设置任务执行结果
 */
public class FutureTask<T> implements Future<T> {
    // 任务执行结果
    private T result;
    // 任务是否被完成
    private boolean isDone = false;
    // 定义对象锁
    private final Object LOCK = new Object();

    @Override
    public T get() throws InterruptedException {
        synchronized (LOCK){
            // 任务没有被执行完阻塞
            while (!isDone){
                LOCK.wait();
            }
            // 执行完成后返回结果
            return result;
        }
    }

    // finish 方法用来接收任务被完成的通知 设置任务执行结果
    protected void finish(T result){
        synchronized (LOCK){
            // balking 设计模式
            if (isDone) return;
            //处理传入的result值 设置返回值 是否完成 唤醒阻塞休息室的线程
            this.result = result;
            this.isDone = true;
            LOCK.notifyAll();
        }
    }

    @Override
    public boolean done() {
        return this.isDone;
    }
}

3. 设计提交任务接口

/**
 * 用于提交任务
 */
public interface FutureService<IN,OUT> {
    // 提供不需要返回值的任务提交方法  Future.get() 方法返回null
    Future<?> submit(Runnable runnable);
    // 提供需要返回值的任务提交方法
    Future<OUT> submit(Task<IN,OUT> task,IN input);
    // 静态实现类方法
    static <T,R> FutureService<T,R> newService(){
        return new FutureServiceImpl<>();
    }
}

4. 有输入输出的逻辑执行单元接口

/**
 * 任务逻辑执行单元 和runnable一样的功能
 */
@FunctionalInterface
public interface Task<IN,OUT> {
    // 给定一个参数返回一个结果
    OUT get(IN input);
}

5. 设计提交任务实现类 实现异步执行

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 主要作用在于当提交任务时创建一个线程来执行该任务，来达到异步执行的效果
 */
public class FutureServiceImpl<IN,OUT> implements FutureService<IN,OUT> {

    // 为创建的线程 前缀起名
    private final static String FUTURE_THREAD_NAME="future-";
    // 自增Int 为线程的名称后缀服务
    private final AtomicInteger nextNum = new AtomicInteger(0);
    private String getNextName(){
        return FUTURE_THREAD_NAME+nextNum.getAndDecrement();
    }

    @Override
    public Future<?> submit(Runnable runnable) {
        final FutureTask<Void> future = new FutureTask<>();
        new Thread(() -> {
            runnable.run();
            // 将任务执行结果给FutureTask处理
            future.finish(null);
        },getNextName()).start();
        return future;
    }

    @Override
    public Future<OUT> submit(Task<IN, OUT> task, IN input) {
        final FutureTask<OUT> future = new FutureTask<>();
        new Thread(() -> {
            OUT result = task.get(input);
            // 将任务执行结果给FutureTask处理
            future.finish(result);
        },getNextName()).start();
        return future;
    }
}

6. 测试类

public static void main(String[] args) throws InterruptedException {
        FutureService<Void, Void> futureService = FutureService.newService();
        Future<?> future = futureService.submit(() -> {
            // 任务执行代码块 用休眠来代替
            System.out.println("----------开始--------------");
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("------------结束-----------------");
        });
        future.get();
        System.out.println(" 是否执行完成 "+future.done());

        // 没有添加 通过凭证获取执行结果 future.get();
        // 是否执行完成 false
        //----------开始--------------
        //------------结束-----------------

        // 添加 通过凭证获取执行结果
        //----------开始--------------
        //------------结束-----------------
        // 是否执行完成 true



// 有输入输出的 任务提交
        FutureService<String, Integer> service = FutureService.newService();
        Future<Integer> future2 = service.submit(input -> {
            try {
                System.out.println("-----------------------------");
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return input.length();
        }, "hello world");
        System.out.println(" 是否执行完成 "+future2.done());
        System.out.println("  执行结果 " +future2.get());
    }

7. future.get() 调用会导致阻塞，所以可以添加回调接口Callback来实现处理执行结果。

/**
 * 回调接口处理 任务执行结果
 */
@FunctionalInterface
public interface Callback<T> {
    // 任务完成处理结果方法  函数式编程
    void call(T t);
}

8. 处理任务提交接口的

//接口
// 提供需要返回值的任务提交方法
    Future<OUT> submit(Task<IN,OUT> task,IN input,Callback<OUT> callback);

// 实现类
 @Override
    public Future<OUT> submit(Task<IN, OUT> task, IN input,Callback<OUT> callback) {
        final FutureTask<OUT> future = new FutureTask<>();
        new Thread(() -> {
            OUT result = task.get(input);
            // 将任务执行结果传给FutureTask
            future.finish(result);
            // 执行回调接口
            if (null != callback){
                callback.call(result);
            }
        },getNextName()).start();
        return future;
    }

// 测试
// 有输入输出的 任务提交
        FutureService<String, Integer> service = FutureService.newService();
        Future<Integer> future2 = service.submit(input -> {
            try {
                System.out.println("-----------------------------");
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return input.length();
        }, "hello world",System.out::println);
        System.out.println(" 是否执行完成 "+future2.done());