JAVA并发编程系列(13)Future、FutureTask异步小王子

//Runnable接口，只有一个run方法
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

//Callable接口，只有一个call方法
@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

//本文主角Future有5个方法
public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

package lading.java.mutithread;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * 模拟外卖订单处理，客户支付提交订单后，查询订单详情，后台
 * 通过查询店铺备餐进度、以及外卖员目前位置信息。
 */
public class Demo015Future {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1、异步查询商家系统任务
        FutureTask<Boolean> checkFoodIsReadyTask = new FutureTask<>(() -> {
            System.out.println(Thread.currentThread().getName()+"转发请求到商家系统，查询餐厅当前订单备餐进度...");
            Thread.sleep(2000);
            boolean foodIsOk = true;
            System.out.println(Thread.currentThread().getName()+"商家接口返回是否备餐完成，结果是：" + foodIsOk);
            return foodIsOk;
        });
        //2、异步查询外卖员系统任务
        FutureTask<Boolean> checkCourierIsReadyTask = new FutureTask<>(() -> {
            System.out.println(Thread.currentThread().getName()+"转发请求到外卖员系统，查询外卖员是否已到店...");
            Thread.sleep(800);
            boolean courierIsOk = true;
            System.out.println(Thread.currentThread().getName()+"查询外卖员是否已到店，结果是：" + courierIsOk);
            return courierIsOk;
        });
        //并发查询商家、外卖员情况，大约2s
        new Thread(checkFoodIsReadyTask).start();
        new Thread(checkCourierIsReadyTask).start();
        Thread.sleep(100);
        //只是判断是否完成，不会阻塞
        if (!checkFoodIsReadyTask.isDone()) {
            System.out.println(Thread.currentThread().getName() + "查询店铺备餐进度未完成，继续等等...");
        }
        if (!checkCourierIsReadyTask.isDone()) {
            System.out.println(Thread.currentThread().getName() + "查询外卖员情况未完成，继续等等...");
        }
        //如果结果没返回会阻塞等待
        System.out.println(Thread.currentThread().getName() + "线程 成功查到商家备餐结果：" + checkFoodIsReadyTask.get());
        System.out.println(Thread.currentThread().getName() + "线程 成功查到外卖员结果：" + checkCourierIsReadyTask.get());
    }
}

//当前任务线程的状态，以下几个枚举值都是state不同状态
private volatile int state;
 
//当前任务线程刚创建状态
private static final int NEW          = 0;
//当前任务线程即将完成，ing是一个即将完成状态
private static final int COMPLETING   = 1;
//表示当前任务线程正常结束的状态
private static final int NORMAL       = 2;
//表示当前任务线程有异常
private static final int EXCEPTIONAL  = 3;
//表示当前任务线程被取消
private static final int CANCELLED    = 4;
//表示当前线程已经被打了中断标识
private static final int INTERRUPTING = 5;
//表示当前线程已经被中断
private static final int INTERRUPTED  = 6;

//Callable 来执行任务，Callable 有返回值的线程
private Callable<V> callable;
 
//Callable任务执行的返回结果
private Object outcome; 
 
//当前正在运行的线程
private volatile Thread runner;
 
//等待队列节点，WaitNode是FutureTask的内部类
private volatile WaitNode waiters;

//等待队列源码
    static final class WaitNode {
        //被阻塞的线程，也就
        volatile Thread thread;
        //这里看出它就是个单向队列
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); }
    }

protected void set(V v) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }

public V get() throws InterruptedException, ExecutionException {
        int s = state;
        //1、如果任务没执行完成，当前想读取任务结果的线程就进入阻塞等待
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        //2、如果任务执行完成，就返回结果    
        return report(s);
    }

//当前任务状态是否被取消，直接读状态值
    public boolean isCancelled() {
        return state >= CANCELLED;
    }
    //当前任务状态是否以及执行结束，直接读状态值
    public boolean isDone() {
        return state != NEW;
    }