Callable/Future Runnable 以及 FutureTask 用法

Callable/Future  Runnable 以及 FutureTask 用法，代码示例：

import java.util.concurrent.*;

public class Test {
    private static ExecutorService executorService = Executors.newCachedThreadPool();

    public static void main(String[] args) throws Exception {
        testFuture();
        System.out.println("===================");
        testFutureTask();
    }

    public static void testFuture() throws ExecutionException, InterruptedException {
        /**
         * submit 可以返回一个匿名的 Future 实现，通过该实现可以进行 取消/获取等待 等操作
         * get() 会阻塞知道结果拿到
         */
        Future future = executorService.submit(new MyCallable(1));
        System.out.println(future.isDone());
        System.out.println(future.get());
        System.out.println(future.isDone());
    }

    public static void testFutureTask() throws ExecutionException, InterruptedException {
//        FutureTask<Object> futureTask = new FutureTask<Object>(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("业务方法被调用！" + Thread.currentThread().getName());
//            }
//        }, "result flag");// 由于 Runnable 没有返回值，这里需要显示 指定， 可以是任意值

        FutureTask<String> futureTask = new FutureTask<>(new MyCallable(200));
        System.out.println("futureTask instanceof Future:" + (futureTask instanceof Future));
        /**
         * FutureTask 本身即是一个 Runnable ，所以可以直接进行 .execute(futureTask); like a Runnable
         * 同时也可使用 FutureTask 的 取消/获取等待 等操作， like a Future
         *
         * FutureTask 可以看作是 Runnable 和 Future 的整合体，
         * 通过使用FutureTask，不必在使用 ExecutorService的接口：<T> Future<T> submit(Callable<T> task);
         *
         * 技术本质：
         * 之前：<T> Future<T> submit(Callable<T> task)返回一个匿名的Future实现，
         * 现在：使用 FutureTask 显示 实现Future
         * (FutureTask instanceof Future) == true
         *
         * Other Note:
         * FutureTask 同时支持Runnable ：FutureTask(Runnable runnable, V result)
         * 所以对Executor.execute(Runnable command);编程可以只面向 FutureTask，而无需区分 Runnable 和 Callable
         */
        executorService.execute(futureTask);// do not need submit(xx)
        System.out.println(futureTask.isDone());
        System.out.println(futureTask.get());
        System.out.println(futureTask.isDone());
    }
}

class MyCallable implements Callable {
    private int id;

    public MyCallable(int id) {
        this.id = id;
    }

    @Override
    public String call() throws Exception {
        System.out.println("call()方法被调用！" + Thread.currentThread().getName());
        Thread.sleep(2000);
        return "结果是：" + id;
    }
}