获取线程的执行结果

无返回值的 Runnable

public interface Runnable {
    public abstract void run();
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
    // 创建一个包含5个线程的线程池
    ExecutorService executorService = Executors.newFixedThreadPool(5);
 
    // 创建一个Runnable任务
    Runnable task = new Runnable() {
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    };
 
    // 提交任务到ExecutorService执行
    for (int i = 0; i < 10; i++) {
        executorService.submit(task);
    }
 
    // 关闭ExecutorService，不再接受新的任务，等待所有已提交的任务完成
    executorService.shutdown();
}

有返回值的 Callable

public interface Callable<V> {
    V call() throws Exception;
}

Callable 一般配合 ExecutorService 接口使用，它是 Java 线程池框架的核心接口，用来异步执行任务。它提供了一些关键方法用来进行线程管理。

• submit 方法既可以传入 Runnable 接口也可以传入 Callable接口

public static void main(String[] args) throws ExecutionException, InterruptedException {
    // 创建一个包含5个线程的线程池
    ExecutorService executorService = Executors.newFixedThreadPool(5);
 
    // 创建一个Callable任务
    Callable<String> task = new Callable<String>() {
        @Override
        public String call() throws Exception {
            return Thread.currentThread().getName();
        }
    };
 
    // 提交任务到ExecutorService执行，并获取Future对象
    Future[] futures = new Future[10];
    for (int i = 0; i < 10; i++) {
        futures[i] = executorService.submit(task);
    }
 
    // 通过Future对象获取任务的结果
    for (int i = 0; i < 10; i++) {
        System.out.println(futures[i].get());
    }
 
    // 关闭ExecutorService，不再接受新的任务，等待所有已提交的任务完成
    executorService.shutdown();
}

异步计算结果 Future 接口

public interface Future<V> {
    // 用来取消任务，如果取消任务成功则返回 true，如果取消任务失败则返回 false。参数 mayInterruptIfRunning 表示是否允许取消正在执行却没有执行完毕的任务，如果设置 true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论 mayInterruptIfRunning 为 true 还是 false，此方法肯定返回 false，即如果取消已经完成的任务会返回 false；如果任务正在执行，若 mayInterruptIfRunning 设置为 true，则返回 true，若 mayInterruptIfRunning 设置为 false，则返回 false；如果任务还没有执行，则无论 mayInterruptIfRunning 为 true 还是 false，肯定返回 true。
    boolean cancel(boolean mayInterruptIfRunning);
    // 表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true
    boolean isCancelled();
    // 表示任务是否已经完成，若任务完成，则返回 true
    boolean isDone();
    // 用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回
    V get() throws InterruptedException, ExecutionException;
    // 用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回 null
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future 提供了三种功能：

• 1）判断任务是否完成；
• 2）能够中断任务；
• 3）能够获取任务执行结果。

FutureTask 是 Future 接口的一个唯一实现类，前面的例子中 executorService.submit() 返回的就是 FutureTask

异步计算结果 FutureTask 实现类

// 继承了 Runnable 接口和 Future 接口，而 FutureTask 实现了 RunnableFuture 接口。所以它既可以作为 Runnable 被线程执行，又可以作为 Future 得到 Callable 的返回值。
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

public class FutureTask<V> implements RunnableFuture<V> {
    public FutureTask(Callable<V> callable) {}
 
    public FutureTask(Runnable runnable, V result) {}
    ...
}

当需要异步执行一个计算并在稍后的某个时间点获取其结果时，就可以使用 FutureTask

public static void main(String[] args) throws ExecutionException, InterruptedException {
    // 创建一个固定大小的线程池
    ExecutorService executorService = Executors.newFixedThreadPool(3);
 
    // 创建一系列 Callable
    Callable<Integer>[] tasks = new Callable[5];
    for (int i = 0; i < tasks.length; i++) {
        final int index = i;
        tasks[i] = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                TimeUnit.SECONDS.sleep(index + 1);
                return index + 1;
            }
        };
    }
 
    // 将 Callable 包装为 FutureTask，并提交到线程池
    FutureTask<Integer>[] futureTasks = new FutureTask[tasks.length];
    for (int i = 0; i < tasks.length; i++) {
        futureTasks[i] = new FutureTask<>(tasks[i]);
        executorService.submit(futureTasks[i]);
    }
 
    // 获取任务结果
    for (int i = 0; i < futureTasks.length; i++) {
        System.out.println("Result of task" + (i + 1) + ": " + futureTasks[i].get());
    }
 
    // 关闭线程池
    executorService.shutdown();
}