Callable和Future、FutureTask

Java中除了Runnable接口，还有Callable接口。

两者区别是，后者可以有返回值，一般用于耗时计算。

Runnable接口在线程中用得比较多，一般可以作为线程执行体，Callable一般会与FutureTask结合使用。

Callable接口的源码如下：

/**
* 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.
* Callable接口类似于Runnable接口，都是设计用于被其他线程执行的类实例。
* 但是Runnable接口不返回结果，不能抛出一个受检异常。
*
* <p>The {@link Executors} class contains utility methods to
* convert from other common forms to {@code Callable} classes.
* Executors类包含将其他通用形式转成Callable类的辅助类。
*
* @see Executor
* @since 1.5
* @author Doug Lea
* @param <V> the result type of method {@code call}
*/
@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;
}

Future接口用于表示异步计算的结果，该接口包含检查计算是否结束、等待计算结束、获取计算结果的方法。

其中get()可以获取计算结果，在计算完成之前，会一直阻塞当前线程。计算可以被取消。

FutureTask实现了RunnableFuture接口：

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

而RunnableFuture接口继承自Runnable和Future：

public interface RunnableFuture<V> extends Runnable, Future<V> {

FutureTask表示可取消的异步计算，作为Future接口的实现。FutureTask可以包装Runnable接口，

另外因为实现了Runnable接口，所以可以提交给Executor执行。

下面用代码测试一下：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
public static void main(String[] args) throws InterruptedException, ExecutionException {

Runnable runnable = new Runnable() {

@Override
public void run() {
System.out.println("runnable running");
}
};

Callable<Integer> callable = new Callable<Integer>() {

@Override
public Integer call() throws Exception {
System.out.println("callable running");

return 123;
}
};

Callable<Integer> callable1 = new Callable<Integer>() {

@Override
public Integer call() throws Exception {
System.out.println("callable1 running");

return 123;
}
};

//runnable
Thread thread1 = new Thread(runnable);
thread1.start();

//callable
FutureTask<Integer> future = new FutureTask<Integer>(callable);
Thread thread2 = new Thread(future);
thread2.start();

System.out.println("future is done? "+future.isDone());
//future.cancel(false);
Thread.sleep(1000);
System.out.println("future result: "+future.get());

ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0L,
TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());

executor.execute(runnable);

FutureTask<Integer> future1 = new FutureTask<Integer>(callable1);
executor.execute(future1);

FutureTask<String> ft = new FutureTask<String>(runnable, "aaaaa");
Thread thread3 = new Thread(ft);
thread3.start();
while(!ft.isDone()){
Thread.sleep(1000);
}
System.out.println("future runnable result: "+ft.get());

Future<Integer> futureTask = executor.submit(callable);
while(!futureTask.isDone()){
Thread.sleep(1000);
}
System.out.println("futureTask result: "+futureTask.get());
executor.shutdown();

}
}

输出结果：

runnable running

future is done? false

callable running

future result: 123

runnable running

callable1 running

runnable running

future runnable result: aaaaa

callable running

futureTask result: 123