//FutureTask的一个构造方法：
public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
}

//Executors的callable方法，返回一个RunnableAdapter实例：
public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
}

//RunnableAdapter是Executors的静态内部类，实现Callable接口
static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
}

Thread thread = new Thread(new TaskA());
thread.start();

TaskB task = new TaskB();
task.start();

TaskC task = new TaskC();
//带有返回值的线程
FutureTask<Integer> future = new FutureTask<Integer>(task);
Thread thread = new Thread(future);
thread.start();
System.out.println("获取Callable任务的返回值：" + future.get());
//FutureTask也可以运行Runnable任务，FutureTask会在构造方法里面将Runnable转换为Callable， 指定的返回值为 线程的返回值
FutureTask<Integer> future1 = new FutureTask<Integer>(new TaskA(), 2);
thread = new Thread(future1);
thread.start();
System.out.println("获取Runnable任务的返回值：" + future1.get());

//创建一个同时只能执行一个任务的线程池
ExecutorService service = Executors.newSingleThreadExecutor();
TaskA taskA = new TaskA();
TaskB taskB = new TaskB();
//execute只能执行Runnable类型的任务，没有返回值
service.execute(taskA);
service.execute(taskB);
//submit执行Runnable类型的任务，返回值为null
Future<?> future = service.submit(taskA);
System.out.println("获取Runnable任务的返回值：" + future.get());
future = service.submit(taskA,2);
System.out.println("获取Runnable任务的返回值：" + future.get());
TaskC taskCallable = new TaskC();
future = service.submit(taskCallable);
System.out.println("获取Callable任务的返回值：" + future.get());