Callable和FutureTask
Callable
Callable与Runnable的功能大致相似，Callable中有一个call()函数，但是call()函数有返回值，而Runnable的run()函数不能将结果返回给客户程序。Callable的声明如下 :
public interface Callable {
/** * 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;
}
通过Executors的静态函数callable(Runnable task,...)可将Runnable转换为Callable类型，该适配函数的实现如下 ：
public static Callable callable(Runnable task, T result) {
if (task == null) throw new NullPointerException();
return new RunnableAdapter(task, result);
}
RunnableAdapter适配器
static final class RunnableAdapter implements Callable {
final Runnable task; final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}
暂时只需要知道Callable一般是和ExecutorService配合来使用的，具体的使用方法讲在后面讲述。
Future
Executor就是Runnable和Callable的调度容器，Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作。get方法会阻塞，直到任务返回结果。Future声明如下 :
public interface Future {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}
FutureTask
FutureTask则是一个RunnableFuture，而RunnableFuture实现了Runnbale又实现了Futrue这两个接口，
public class FutureTask implements RunnableFuture {
...
}
public interface RunnableFuture extends Runnable, Future {
/** * Sets this Future to the result of its computation * unless it has been cancelled. */
void run();
}
另外它还可以包装Runnable和Callable， 由构造函数注入依赖。
public FutureTask(Callable 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
}
使用
那么怎么使用这些类呢呢？一般情况下是配合ExecutorService来使用的，在ExecutorService接口中声明了若干个submit方法的重载版本：
- <T> Future<T> submit(Callable<T> task);
- <T> Future<T> submit(Runnable task, T result);
- Future<?> submit(Runnable task);
第一个submit方法里面的参数类型就是Callable,
第二个和第三个是可以看到，Runnable注入会被Executors.callable()函数转换为Callable类型，即FutureTask最终都是执行Callable类型的任务。
并且还可以直接通过get()函数获取执行结果，该函数会阻塞，直到结果返回。因此FutureTask既是Future、
Runnable，又是包装了Callable( 如果是Runnable最终也会被转换为Callable )， 它是这两者的合体。因为一般FutureTask是在Executor中执行，但Executor只能执行Runnable，所以将Callable进行了封装。
由于FutureTask实现了Runnable，因此它既可以通过Thread包装来直接执行，也可以提交给ExecuteService来执行。运用示例代码如下：
/** * Created by SilenceDut on 16/7/18. */
public class FutureTest {
public static void main(String[] args) {
FutureTest futureTest = new FutureTest();
futureTest.useExecutor();
futureTest.useThread();
}
private void useExecutor() {
SumTask sumTask = new SumTask(1000);
ExecutorService executor =
Executors.newCachedThreadPool();
FutureTask<Integer> futureTask = new
FutureTask<Integer>(sumTask);
executor.submit(futureTask);
executor.shutdown();
try {
System.out.println(Thread.currentThread().getName()+"useExecutor运行结果" + futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
private void useThread() {
SumTask sumTask = new SumTask(500);
FutureTask<Integer> futureTask = new FutureTask<Integer>(sumTask) {
@Override
protected void done() {
super.done();
try {
// 这是在后台线程
System.out.println(Thread.currentThread().getName()+"useThread运行结果" + get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
};
Thread thread = new Thread(futureTask);
thread.start();
try {
//这是在主线程，会阻塞
System.out.println(Thread.currentThread().getName()+"useThread运行结果" + futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
class SumTask implements Callable<Integer> {
int number;
public SumTask(int num) {
this.number = num;
}
@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName());
Thread.sleep(5000);
int sum = 0;
for (int i = 0; i < number; i++) {
sum += i;
}
return sum;
}
}
}
结果：
pool-1-thread-1
main::useExecutor运行结果499500
Thread-0
main::useThread运行结果124750
Thread-0::useThread运行结果124750
参考《Android进阶开发—从小工到专家》
