几个任务执行相关的类

Runnable

正面就是Runnable的完整定义，非常简单。

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

Callable

Callable和Runnable的功能非常相似，一样的简捷，但是Callable更强大。

public interface Callable<V> {
V call() throws Exception;
}

首先说明一点，interface中的方法必然都是抽象方法，"abstract"关键字可以不写。
与Runnable的三点不同：

Callable是基于泛型的，而Runnable不是。
Callable可以返回一个值，而Runnable不可以。
Callable可以抛出异常，而Runnable捕获异常后必须自己处理，不能抛出。

Thread

public class Thread implements Runnable {
...
}

启动一个线程要使用start()，而不要去调用run()。stop()、destroy()suspend()、resume()已经废弃不再建议使用了。

Future

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

cancel用于取消任务的执行，取消成功后返回true，然后任务就再也不能被执行了，参数mayInterrupted决定是否让执行任务的线程被中断。

当任务在完成之前被取消则isCancelled返回true。

当任务正常完成、或被取消、或收到异常，则isDone返回true。

get()阻塞直到计算完成，并返回计算结果。

Executor

Executor框架主要是作为线程池来使用的。

public interface Executor {
void execute(Runnable command);
}

提交给Executor去执行的任务可以是一个Runnable，下面马上可以看到提交给ExecutorService去执行的任务除了Runnable，也可以是Callable。而ExecutorService继承了Executor。

ExecutorService

public interface ExecutorService extends Executor {

void shutdown();

List<Runnable> shutdownNow();

boolean isShutdown();

boolean isTerminated();

boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;

<T> Future<T> submit(Callable<T> task);

<T> Future<T> submit(Runnable task, T result);

Future<?> submit(Runnable task);

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;

<T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException;

<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}

shutdown是不接收新的任务，但队列中等待的任务还会将它们执行完。shutdownNow是立即强行关闭，并且返回从未开始执行的任务列表。isDhutdown关心Executor是不是shutdown了，而isTerminated关心是不是所有的Tasks已经shutdown了。
awaitTermination将一直阻塞，直到以下3者之一发生：

调用了shutdown，且所有任务都已结束。
超时timeout
抛出异常

submit用于提交一个任务去执行，返回一个Future，通过Future的get()方法来获得任务运行的结果。

InvokeAll提交一组任务，并且返回一组Future。与submit不同，InvokeAll只有当所有任务都完成后才返回--除非调用者线程被中断或者超时，若超时，那么没有被执行的任务将被取消。这样一来，InvokeAll返回的Future列表在调用IsDone时都将返回true。
当Tasks中任意一个完成时，invokeAny就将返回其计算结果，剩下的没有执行完的任务将被取消。注意如果在invokeAny运行期间，collection参数被修改了，那invokeAny返回的结果是不可预知的。

Executors

Executors提供一系列的静态工厂方法用于产生ExecutorSerive、ScheduledExecutorService、ThreadFactory和Callable。

RunnableFuture

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

FutureTask

FutureTask通常用于封装一个Callable或Runnable对象，由于它继承了Runnable，所以它可以交给Executor去执行。它有一个内部类Sync，用于同步控制。

public class FutureTask<V> implements RunnableFuture<V> {
private final Sync sync;

public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
sync = new Sync(callable);
}

public FutureTask(Runnable runnable, V result) {
sync = new Sync(Executors.callable(runnable, result));
}

public boolean isCancelled() {
return sync.innerIsCancelled();
}

public boolean isDone() {
return sync.innerIsDone();
}

public boolean cancel(boolean mayInterruptIfRunning) {
return sync.innerCancel(mayInterruptIfRunning);
}

public V get() throws InterruptedException, ExecutionException {
return sync.innerGet();
}

public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
return sync.innerGet(unit.toNanos(timeout));
}

protected void done() { }

protected void set(V v) {
sync.innerSet(v);
}

protected void setException(Throwable t) {
sync.innerSetException(t);
}

public void run() {
sync.innerRun();
}

protected boolean runAndReset() {
return sync.innerRunAndReset();
}
}

CompletionService

如果向Excutor提交了一组任务，并且希望在计算完成之后获取结果，需要调用Future的get通过轮询的方法来判断任务是否完成。这种方法有些繁琐。CompletionService将Executor和BlockingQueue整合在一起，可以提交Callable给它执行，然后使用类似于队列操作take()和poll()等方法来获得已完成的结果，而这些结果在完成时被封装为Future。

public interface CompletionService<V> {

Future<V> submit(Callable<V> task);

Future<V> submit(Runnable task, V result);

Future<V> take() throws InterruptedException;

Future<V> poll();

Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException;
}

take和poll都将移除队首元素，不同的是：当目前没有任务完成时take将一直阻塞，而poll将立即返回null。
ExecutorCompletionService是CompletionService的具体实现类。