Java线程池详解：Future的使用和实现

java复制代码 public interface ExecutorService extends Executor {
    // 提交Callable任务并返回任务的Future
      Future submit(Callable task);
    // 从返回的Future中获取到执行结果为result
      Future submit(Runnable task, T result);
    // 从返回的Future中获取到执行结果为null
    Future submit(Runnable task);
}

java复制代码package java.util.concurrent;

    public interface Future {    
        /**
         * 等待任务执行完成，并获取其结果。
         * Throws：
         *  CancellationException - 如果任务被取消
         *  ExecutionException - 如果任务发生异常
         *  InterruptedException - 如果当前线程在等待时被中断
         */
        V get() throws InterruptedException, ExecutionException;
        
        // 等待指定时间任，并获取其结果。若指定时间内任务还在执行则抛出TimeoutException
        V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
    }
}

java复制代码ExecutorService es = Executors.newFixedThreadPool(1);
Future f = es.submit(new Callable() {
    @Override
    public Date call() throws Exception {
        Thread.sleep(5000);
        return new Date();
    }
});
try {
    f.get(2000, TimeUnit.MILLISECONDS);
} catch (TimeoutException e) {
    System.out.println("timeout");
}

// 输出：
timeout

csharp复制代码ExecutorService es = Executors.newFixedThreadPool(1);
Future f = es.submit(new Runnable() {
    @Override
    public void run() {
        throw new RuntimeException("task throw error test");
    }
});
//  等待任务执行完成，并获取其结果。
try {
    f.get();
} catch (ExecutionException e) {
    System.out.println(e.getCause().getMessage());
}

输出：
task throw error test

java复制代码package java.util.concurrent;

public interface Future { 
    // 如果任务无法取消，通常是因为它已经完成，则返回false；否则返回true。
    boolean cancel(boolean mayInterruptIfRunning);
}

java复制代码Future f = es.submit(new Runnable() {
@Override
public void run() {
    Thread thread = Thread.currentThread();
    // 未被中断则一直执行
    while (!thread.isInterrupted()) {
        System.out.println(thread.getName() + ": running");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // sleep方法会影响中断抛出异常并清除中断状态，所以这里恢复中断状态供while判断
            thread.interrupt();
        }
    }
    System.out.println(thread.getName() + ": end");
}
});
// 等待一会确保任务被发起执行
Thread.sleep(2_000);
// 取消任务，通过发送中断来取消
f.cancel(true);

java复制代码 /*
 * 任务是否已完成。
 * 完成可能是由于正常终止、异常或取消，在所有这些情况下，该方法将返回true。
 */
boolean isDone();

/*
 * Future是否已经被取消
 * 在调用cancel后，无论cancel是否返回true改返回都将始终返回true。
 */
boolean isCancelled();

java复制代码protected  RunnableFuture newTaskFor(Runnable runnable, T value) {
    return new FutureTask(runnable, value);
}

java复制代码FutureTask f = new FutureTask<>(new Callable() {
    @Override
    public Date call() throws Exception {
        return new Date();
    }
});
f.run();
Date d = f.get();

java复制代码public class FutureTask implements RunnableFuture {
    private volatile int state;

    private static final int NEW          = 0;
    // 任务执行结束，更新执行结果中 
    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;
}

java复制代码public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    return report(s);
}

java复制代码public class FutureTask implements RunnableFuture {
    // 为Callable任务生成FutureTask
    public FutureTask(Callable callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;
    }
    // 为Runnable任务生成FutureTask
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;
    }
}

java复制代码public class FutureTask implements RunnableFuture {
    protected void done() { }
}