Java中Callable和Future——简介

一、Java线程实现基础

---

java中实现一个线程的方法是继承(extends)Thread类或者实现(implements)Runnable接口（我个人认为通过线程池启线程也算是）。

继承Thread类：

class A extends Thread{
        @Override
        public void run() {
            //TODO 
        }
    }

实现Runnable接口：

class B implements Runnable{
        @Override
        public void run() {
            //TODO 
        }
    }

抑或分别使用匿名内部类，如下：

new Thread(){
    public void run() {
       //TODO 操作
    };
}.start();

new Thread(
    new Runnable() {
        @Override
        public void run() {
            //TODO 操作
        }
    }
).start();

其实Thread类自身就实现了Runnable接口：

public class Thread implements Runnable{
}

---

二、Callable和Runnable

---

Callable和Runnable接口申明定义分别如下：

/**
 * A task that returns a result and may throw an exception.
 * Implementors define a single method with no arguments called
 * {@code call}.
 *
 * <p>The {@code Callable} interface is similar to {@link
 * java.lang.Runnable}, in that both are designed for classes whose
 * instances are potentially executed by another thread.  A
 * {@code Runnable}, however, does not return a result and cannot
 * throw a checked exception.
 *
 * <p>The {@link Executors} class contains utility methods to
 * convert from other common forms to {@code Callable} classes.
 *
 */
@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

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

它们都只有一个方法。相对而言，我们对Runnable接口还是比较熟悉。如Callable接口注释所说，我们知道Callable和Runnable类似，都是为其实例可能由另一个线程执行而设计。但是Callable接口是泛型形式，call()方法，有返回值且可抛出异常，即可返回线程执行结果。

---

三、Future和FutureTask

---

3.1、Future介绍：

Future可以对具体的Callable任务进行相关操作：取消/中断当前任务、查询任务是否完成、获取任务结果。其中get()方法会阻塞，直到任务完成返回结果，下一篇介绍其实现原理。Future声明如下（详细请见JDK文档）：

public interface Future<V> {//泛型接口

    /**
     * 取消/中断当前任务
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     *是否已取消/中断当前任务
     */
    boolean isCancelled();

    /**
     * 查询任务是否完成
     */
    boolean isDone();

    /**
     * 获取任务结果（会阻塞）
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     * 获取任务结果（会阻塞）
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

在Future接口说明处已给出了伪代码来说明如何使用：

interface ArchiveSearcher { String search(String target); }

class App {
   ExecutorService executor = ...
   ArchiveSearcher searcher = ...
   void showSearch(final String target)
       throws InterruptedException {
     Future<String> future
       = executor.submit(new Callable<String>() {
         public String call() {
             return searcher.search(target);// 异步线程处理搜索
         }});
     displayOtherThings(); // 在异步搜索的同时，在当前线程中，我们同时干别的事情，爽哉
     try {
       displayText(future.get()); // 通过Future获取异步任务结果
     } catch (ExecutionException ex) { cleanup(); return; }
   }
 }}

3.2、FutureTask介绍：

在Future接口说明处同时也提到其具体实现类FutureTask。先看一下如下类图：

可见FutureTask则是一个RunnableFuture，而RunnableFuture则既继承了Runnbale又继承了Futrue：

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

public class FutureTask<V> implements RunnableFuture<V>{}

另，查看源码发现其构造函数依赖注入Runnbale或Callable，且Runnable会被Executors.callable()转换为Callable类型，即FutureTask最终都是执行Callable类型式任务：

public FutureTask(Callable<V> callable) {
    if (callable == null)
         throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}

/**当不需要返回值时，result可以传null*/ 
public FutureTask(Runnable runnable, V result) {
      this.callable = Executors.callable(runnable, result);//被Executors.callable()转换为`Callable`
      this.state = NEW;       // ensure visibility of callable
}

Executors.callable()相关代码如下：

public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
}

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;
        }
}

综上，可见FutureTask间接实现了Runnable，因此它既可以通过Thread来直接执行，又可以提交给ExecuteService来执行（并且还可以直接通过get()函数获取得到执行结果）,上述Future示例伪代码部分可以改造如下：

FutureTask<String> future =
   new FutureTask<String>(new Callable<String>() {
     public String call() {
       return searcher.search(target);
   }});

 executor.execute(future);

或

FutureTask<String> future =
   new FutureTask<String>(new Callable<String>() {
     public String call() {
       return searcher.search(target);
   }});

 new Thread(future).start();//没使用线程池，只是示意可以这么用