线程创建之Callable+Future+FutureTask

1、前言

 

创建线程有四种方式，分别是实现Runnable接口，继承Thread类，线程池，还有一种就是实现Callable接口。相对于实现Runnable接口和继承Thread类在执行任务后都无法获取执行结果，Callable+Future能够在任务执行结束后得到任务结果。

 

2、Callable和Runnable

 

Runnable是一个接口，只声明了一个run()方法：

?

1 2 3

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

 

由于run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果。Callable位于java.util.concurrent包下，也是一个接口，也只声明了一个叫做call()的方法

?

1 2 3 4 5 6 7 8 9

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

 

Callable是一个泛型接口，call()函数返回的类型就是传递进来泛型。

Callable一般情况下是配合ExecutorService来使用的，在ExecutorService接口中声明了若干个submit方法：

?

1 2 3

<T> Future<T> submit(Callable<T> task); <T> Future<T> submit(Runnable task, T result);//该方法不常用 Future<?> submit(Runnable task);

第一个submit方法里面的参数类型就是Callable。一般情况下我们使用第一个submit方法和第三个submit方法，第二个submit方法很少使用。

 

3、Future

 

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。Future类位于java.util.concurrent包下的一个接口。

?

1 2 3 4 5 6 7 8

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

该接口中声明了五个方法,分别表示：

1、cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。

2、isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。

3、isDone方法表示任务是否已经完成，若任务完成，则返回true；

4、get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；

5、get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

上述表明Future接口提供了三种功能：1、判断任务是否完成 2、能够中断任务 3、能够获取任务执行结果。

 

 

4、FutureTask

 

Future只是一个接口，无法直接用来创建对象，需要具体实现类FutureTask。FutureTask是Future接口的唯一实现类。

?

1 2 3 4

public class FutureTask<V> implements RunnableFuture<V>//FutureTask类实现了RunnableFuture接口，RunnableFuture接口的信息如下： public interface RunnableFuture<V> extends Runnable, Future<V> {     void run(); }

可以看出RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以说明FutureTask既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。类继承图如下：

 

FutureTask除了实现了Future接口外还实现了Runnable接口，因此FutureTask也可以直接提交给Executor执行。 当然也可以调用线程直接执行（FutureTask.run()）。接下来我们根据FutureTask.run()的执行时机来分析其所处的3种状态：

（1）未启动，FutureTask.run()方法还没有被执行之前，FutureTask处于未启动状态，当创建一个FutureTask，而且没有执行FutureTask.run()方法前，这个FutureTask也处于未启动状态。

（2）已启动，FutureTask.run()被执行的过程中，FutureTask处于已启动状态。

（3）已完成，FutureTask.run()方法执行完正常结束，或者被取消或者抛出异常而结束，FutureTask都处于完成状态。

上图是FutureTask的方法执行示意图：

当FutureTask处于未启动或已启动状态时，如果此时我们执行FutureTask.get()方法将导致调用线程阻塞；当FutureTask处于已完成状态时，执行FutureTask.get()方法将导致调用线程立即返回结果或者抛出异常。

当FutureTask处于未启动状态时，执行FutureTask.cancel()方法将导致此任务永远不会执行。当FutureTask处于已启动状态时，执行cancel(true)方法将以中断执行此任务线程的方式来试图停止任务，如果任务取消成功，cancel(...)返回true；但如果执行cancel(false)方法将不会对正在执行的任务线程产生影响(让线程正常执行到完成)，此时cancel(...)返回false。当任务已经完成，执行cancel(...)方法将返回false。

 

Future核心方法：

 

当任务被提交到线程池后，会执行futureTask的run()方法。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

public void run() {     // 校验任务状态         if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))             return;         try {             Callable<V> c = callable;　　　　　　　// double check             if (c != null && state == NEW) {                 V result;                 boolean ran;                 try {　　　　　　　　　　　//执行业务代码                     result = c.call();                     ran = true;                 } catch (Throwable ex) {                     result = null;                     ran = false;                     setException(ex);                 }                 if (ran)                     set(result);             }         } finally {　　　　  // 重置runner             runner = null;             int s = state;             if (s >= INTERRUPTING)                 handlePossibleCancellationInterrupt(s);         }     }

 

这个方法经历了以下几步

1、校验当前任务状态是否为NEW以及runner是否已赋值。这一步是防止任务被取消。

2、double-check任务状态state

3、执行业务逻辑，也就是c.call()方法被执行

4、如果业务逻辑异常，则调用setException方法将异常对象赋给outcome，并且更新state值

5、如果业务正常，则调用set方法将执行结果赋给outcome，并且更新state值

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

protected void setException(Throwable t) {     // state状态 NEW->COMPLETING     if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {         outcome = t;         // COMPLETING -> EXCEPTIONAL 到达稳定状态         UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL);         // 一些结束工作         finishCompletion();     } }　 protected void set(V v) {         // state状态 NEW->COMPLETING         if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {             outcome = v;             // COMPLETING -> NORMAL 到达稳定状态             UNSAFE.putOrderedInt(this, stateOffset, NORMAL);             // 一些结束工作             finishCompletion();         }     }

　

5、应用

 

使用Callable+Future获取执行结果

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

class CallableTask implements Callable<Integer> {     @Override     public Integer call() throws Exception {         System.out.println("子线程进行计算");         Thread.sleep(100);         int sum = 0;         for (int i = 0; i < 100 ; i++) {             sum += i;         }         return sum;     } } public class TestFutureTaskDemo {     public static void main(String[] args) {         ExecutorService executorService = Executors.newCachedThreadPool();         CallableTask callableTask = new CallableTask();         Future<Integer> result = executorService.submit(callableTask);         try {             Thread.sleep(1000);         } catch (InterruptedException e1) {             e1.printStackTrace();         }         System.out.println("主线程在执行任务");         try {             System.out.println("task运行结果:"+result.get());         } catch (InterruptedException e) {             e.printStackTrace();         } catch (ExecutionException e) {             e.printStackTrace();         }         System.out.println("所有任务执行完毕");         executorService.shutdown();     } } 输出： 子线程进行计算 主线程在执行任务 task运行结果4950 所有任务执行完毕

 

使用Callable+FutureTask获取执行结果

 

?

1 2 3 4

ExecutorService executor = Executors.newCachedThreadPool(); CallableTask task = new CallableTask(); FutureTask<Integer> futureTask = new FutureTask<Integer>(task); executor.submit(futureTask);

　　

 

 

6、总结

 

实现Runnable接口和实现Callable接口的区别：

 

1、Runnable是自从java1.1就有了，而Callable是1.5之后才加上去的。

2、Callable规定的方法是call(),Runnable规定的方法是run()。

3、Callable的任务执行后可返回值，而Runnable的任务是不能返回值(是void)。

4、call方法可以抛出异常，run方法不可以。

5、运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

6、加入线程池运行，Callable使用submit方法，Runnable一般使用ExecutorService的execute方法（当然也可以用submit）