多线程--callable、Future、FutureTask

除了Runnable外，JAVA中还有callable、Future、FutureTask这几个线程。
与Runnable不同的是，他们只能运用到线程池中，而Runnable可以使用到Thread中。

一、Callable
他和Runnable功能大致相同，不同的是他有一个返回值。
他的声明如下：

public interface Callable<V> {
//返回V类型的结果
V call() throws Exception{}
}

二、Future
Runnable和Callable都无法对线程进行控制，一旦开始就无法进行管理。而Future可以执行cancel、isDone、get、set等方法。具体声明如下：

public interface Future<V> {
//取消线程
boolean cancel(boolean mayInterruptIfRunning);
//是否已经取消
boolean isCancelled;
//是否已经完成
boolean isDone();
//获取结果，若未完成则阻塞直到任务完成
V get() throws InterruptedException,ExecutionException;
//获取结果，若未完成则阻塞直到任务完成、或者超时。unit为时间单位
V get(long Timeout , TimeUnit unit) throws InterruptedException,ExecutionException,timeoutException;
}

get方法会阻塞直到任务完成，返回结果
三、FutureTask
它是Future接口的实现类，同时还实现了Runnable接口。

public class FutureTask<V> implements RunnableFuture<V> {
public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
    this.callable = Executors.callable(runnable, result);
    this.state = NEW;       // ensure visibility of callable
}
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

可以看见FutureTask实现了 RunnableFuture，而 RunnableFuture继承了Runnable, Future；其中callable和Runnable通过构造函数注入，不过通过代码，我们可以知道注入的Runnable最后也转换为callable类型的任务。
由此可见，FutureTask实现了Runnable接口，可以通过Thread来直接运行，也可以提交到线程池，同时还能通get拿到结果。
现在通过一个DEMO来直观的展示他们之间的区别。

public class mFutureDemo {
    //线程池
    static ExecutorService mExecutor = Executors.newSingleThreadExecutor();
    //主程序
    public static void main(){

    }

    private static void runnable() throws ExecutionException, InterruptedException {
        Future<?> result = mExecutor.submit(new Runnable() {
            @Override
            public void run() {
                fibc(20);
            }
        });
        System.out.print("runnable"+result.get());
    }

    private static void callable() throws ExecutionException, InterruptedException {
        Future<Integer> result = mExecutor.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return fibc(20);
            }
        });
        System.out.print("callable"+result.get());
    }

    private static void futureTask() throws ExecutionException, InterruptedException {
        FutureTask<Integer> task=new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return fibc(20);
            }
        });
        mExecutor.submit(task);

        //也可以和Runnable一样交给Thread来处理。
        //Thread thread=new Thread(task);
        //thread.start();

        System.out.print("futureTask"+task.get());
    }

    //耗时操作
    private static int fibc(int num){
        if (num==0) return 0;
        if (num==1) return 1;
        return fibc(num-1)+fibc(num-2);
    }
}

输出结果为：
runnable null；
callable 6765；
futureTask 6765；

上诉为非常简单的DEMO没有过多的注释，从中我们可以看出：
1、runnable是没有返回值的，callable和futureTask有返回值
2、runnable，callable是通过线程池返回的future来进行管理，无法自行管理；
而futureTask可以自行get返回值
3、其中get方法会阻塞，直到结果出来，才执行的打印语句。