FutureTask

1. FutureTask 简介

在 Executors 框架体系中，FutureTask 用来表示可获取结果的异步任务。

FutureTask 提供了启动和取消异步任务，查询异步任务是否计算结束以及获取最终的异步任务的结果的一些常用的方法。通过get()方法来获取异步任务的结果，但是会阻塞当前线程直至异步任务执行结束。一旦任务执行结束，任务不能重新启动或取消，除非调用runAndReset()方法。

• Future 接口
  • 可以监视目标线程调用 call 的情况，当你调用 future 的 get 方法的时候就可以获取结果。

• FutureTask 类

  • 实现了 RunnableFuture 接口，而 RunnableFuture 继承了 Future 和 Runnable
  • 
  • 既可以作为 Runnable 执行，又可以作为 Future 得到返回值。比如一个费时操作，可以先执行其他操作，再得到线程返回值。

• get 方法：

  • 当FutureTask 处于未启动或已启动状态时，执行FutureTask.get()方法将导致调用线程阻塞。如果FutureTask 处于已完成状态，调用FutureTask.get()方法将导致调用线程立即返回结果或者抛出异常
• cancel 方法
  • 当 FutureTask 处于未启动状态时，执行FutureTask.cancel()方法将此任务永远不会执行；
  • 当 FutureTask 处于已启动状态时，执行FutureTask.cancel(true)方法将以中断线程的方式来阻止任务继续进行，执行FutureTask.cancel(false)将不会对正在执行任务的线程有任何影响；
• 当 FutureTask 处于已完成状态时，执行FutureTask.cancel(...)方法将返回 false。

对 Future 的get()方法和cancel()方法用下图进行总结：

2. FutureTask 的基本使用

public class FutureExample {
    static class MyCallable implements Callable<String> {
        @Override
        public String call() throws Exception {
            log.info("do something in callable");
            Thread.sleep(5000);
            return "Done";
        }
    }
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> future = executorService.submit(new MyCallable());
        log.info("do something in main");
        Thread.sleep(1000);
        String result = future.get();
        log.info("result：{}", result);
    }
}

执行结果：

- do something in main
- do something in callable
- result：Done

FutureTask 方式实现

public static void main(String[] args) throws Exception {
    FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {
        @Override
        public String call() throws Exception {
            log.info("do something in callable");
            Thread.sleep(5000);
            return "Done";
        }
    });
    new Thread(futureTask).start();
    log.info("do something in main");
    Thread.sleep(1000);
    String result = futureTask.get();
    log.info("result：{}", result);
}

A Demo

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class main {
    public static void main(String[] args) {
        try {
            Thread.sleep(5000);// 可能做一些事情
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        DoService doService = new DoService();
        DoService.doAsyncTask(doService.new CallThread());
    }
}
class DoService {
    private static ExecutorService service = Executors.newFixedThreadPool(6);
    public static Future<Object> doAsyncTask(Callable<Object> call) {
        if (call == null) {
            return null;
        }
        return service.submit(call);
    }
    public class CallThread implements Callable<Object> {
        public Object call() throws Exception {
            Thread.sleep(2000);
            System.out.println("Do something complex...");
            return "success";
        }
    }
}