标签：无法 executors set runnable use static sys 新建 设计
Callable 和 Future 是比较有趣的一对组合。当我们需要获取线程的执行结果时，就需要用到它们。Callable用于产生结果，Future用于获取结果。
Callable 是一个接口，它只包含一个call()方法。Callable是一个返回结果并且可能抛出异常的任务。
为了便于理解，我们可以将Callable比作一个Runnable接口，而Callable的call()方法则类似于Runnable的run()方法。
Callable的源码如下：
public interface Callable<V> {
V call() throws Exception;
}
Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。
Executors 类包含一些从其他普通形式转换成 Callable 类的实用方法。
Future 是一个接口。它用于表示异步计算的结果。提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。
Future的源码如下：
boolean cancel(boolean mayInterruptIfRunning)
试图取消对此任务的执行。
V get()
如有必要，等待计算完成，然后获取其结果。
V get(long timeout, TimeUnit unit)
如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。
boolean isCancelled()
如果在任务正常完成前将其取消，则返回 true。
boolean isDone()
如果任务已完成，则返回 true。
在讲解FutureTask之前，先看看Callable, Future, FutureTask它们之间的关系图，如下：
Future表示一个任务的生命周期，并提供了相应的方法来判断是否已经完成或取消，以及获取任务的结果和取消任务等。在Future规范中包含的隐含意义是，任务的生命周期只能前进，不能后退，就像ExecutorService的生命周期一样。当某个任务完成以后，它就永远停留在“完成”状态上。
get方法的行为取决于任务的状态（尚未开始、正在运行、已完成）。如果任务已经完成，那么get会立即返回或者抛出一个Exception，如果任务没有完成，那么get将阻塞并直到任务完成。如果任务抛出了异常，那么get将该异常封装为ExecutionException并重新抛出。如果任务被取消，那么get将抛出CancellationException。如果get抛出了ExecutionException，那么可以通过getCause来获得封装的初始异常。
异常抛出： CancellationException - 如果计算被取消 ExecutionException - 如果计算抛出异常 InterruptedException - 如果当前的线程在等待时被中断 TimeoutException - 如果等待超时
可以通过很多种方法创建一个Future来描述任务。ExecutorService中的所有submit方法都将返回一个Future，从而将一个Runnable 或 Callable 提交给Executor ，并得到一个Future 用来获得任务的执行结果或者取消任务。 还可以显示地为某个任务指定的Runnable或Callable 实例化一个FutureTask。
说明：
(01) RunnableFuture是一个接口，它继承了Runnable和Future这两个接口。RunnableFuture的源码如下：
public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}
(02) FutureTask实现了RunnableFuture接口。所以，也说它实现了Future接口。
先通过一个示例看看Callable和Future的基本用法，然后再分析示例的实现原理。
1 package com.concurrency.TaskExecution_6;
2
3 import java.util.concurrent.Callable;
4 import java.util.concurrent.ExecutionException;
5 import java.util.concurrent.ExecutorService;
6 import java.util.concurrent.Executors;
7 import java.util.concurrent.Future;
8
9 /**
10 * Callable 和 Future实现线程等待
11 * @ClassName: CallableFutureTest
12 * @author Xingle
13 * @date 2014-9-15 下午3:23:30
14 */
15 public class CallableFutureTest {
16
17 public static void main(String[] args) throws InterruptedException, ExecutionException{
18 System.out.println("start main thread ");
19 ExecutorService exec = Executors.newFixedThreadPool(5);
20
21 //新建一个Callable 任务，并将其提交到一个ExecutorService. 将返回一个描述任务情况的Future.
22 Callable<String> call = new Callable<String>() {
23
24 @Override
25 public String call() throws Exception {
26 System.out.println("start new thread ");
27 Thread.sleep(5000);
28 System.out.println("end new thread ");
29 return "返回内容";
30 }
31 };
32
33 Future<String> task = exec.submit(call);
34 Thread.sleep(1000);
35 String retn = task.get();
36 //关闭线程池
37 exec.shutdown();
38 System.out.println(retn+"--end main thread");
39 }
40
41 }
执行结果：
submit()在java/util/concurrent/AbstractExecutorService.java中实现，它的源码如下：
1 public <T> Future<T> submit(Callable<T> task) {
2 if (task == null) throw new NullPointerException();
3 // 创建一个RunnableFuture对象
4 RunnableFuture<T> ftask = newTaskFor(task);
5 // 执行“任务ftask”
6 execute(ftask);
7 // 返回“ftask”
8 return ftask;
9 }
说明：submit()通过newTaskFor(task)创建了RunnableFuture对象ftask。它的源码如下：
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
FutureTask的构造函数如下：
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
// callable是一个Callable对象
this.callable = callable;
// state记录FutureTask的状态
this.state = NEW; // ensure visibility of callable
}
继续回到submit()的源码中。
在newTaskFor()新建一个ftask对象之后，会通过execute(ftask)执行该任务。此时ftask被当作一个Runnable对象进行执行，最终会调用到它的run()方法；ftask的run()方法在java/util/concurrent/FutureTask.java中实现，源码如下：
1 public void run() {
2 if (state != NEW ||
3 !UNSAFE.compareAndSwapObject(this, runnerOffset,
4 null, Thread.currentThread()))
5 return;
6 try {
7 // 将callable对象赋值给c。
8 Callable<V> c = callable;
9 if (c != null && state == NEW) {
10 V result;
11 boolean ran;
12 try {
13 // 执行Callable的call()方法，并保存结果到result中。
14 result = c.call();
15 ran = true;
16 } catch (Throwable ex) {
17 result = null;
18 ran = false;
19 setException(ex);
20 }
21 // 如果运行成功，则将result保存
22 if (ran)
23 set(result);
24 }
25 } finally {
26 runner = null;
27 // 设置“state状态标记”
28 int s = state;
29 if (s >= INTERRUPTING)
30 handlePossibleCancellationInterrupt(s);
31 }
32 }
说明：run()中会执行Callable对象的call()方法，并且最终将结果保存到result中，并通过set(result)将result保存。
之后调用FutureTask的get()方法，返回的就是通过set(result)保存的值。
http://www.cnblogs.com/xingele0917/p/3973140.html
标签：无法 executors set runnable use static sys 新建 设计
原文地址：http://www.cnblogs.com/H-BolinBlog/p/6810597.html
