• FutureTask

     Future是我们在使用java实现异步时最常用到的一个类，我们可以向线程池提交一个Callable，并通过future对象获取执行结果。本篇文章主要讲述了JUC中FutureTask中的一些实现原理。使用的jdk版本是1.7。

    Future

    　　Future是一个接口，它定义了5个方法：

    1 boolean cancel(boolean mayInterruptIfRunning);
2 boolean isCancelled();
3 boolean isDone();
4 V get() throws InterruptedException, ExecutionException;
5 V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;

    简单说明一下接口定义

    • boolean cancel(boolean mayInterruptInRunning) 取消一个任务，并返回取消结果。参数表示是否中断线程。
    • boolean isCancelled()                                        判断任务是否被取消
    • Boolean isDone() 　　                                       判断当前任务是否执行完毕，包括正常执行完毕、执行异常或者任务取消。
    • V get()                                                            获取任务执行结果，任务结束之前会阻塞。
    • V get(long timeout, TimeUnit unit)                    在指定时间内尝试获取执行结果。若超时则抛出超时异常 

        写个简单demo：

     1 public class FutureDemo {
 2       public static void main(String[] args) {
 3           ExecutorService executorService = Executors.newCachedThreadPool();
 4           Future future = executorService.submit(new Callable<Object>() {
 5               @Override
 6               public Object call() throws Exception {
 7                   Long start = System.currentTimeMillis();
 8                   while (true) {
 9                       Long current = System.currentTimeMillis();
10                      if ((current - start) > 1000) {
11                          return 1;
12                      }
13                  }
14              }
15          });
16   
17          try {
18              Integer result = (Integer)future.get();
19              System.out.println(result);
20          }catch (Exception e){
21              e.printStackTrace();
22          }
23      }
24 }

    这里模拟了1s钟的CPU空转，当执行future.get()的时候，主线程阻塞了大约一秒后获得结果。

       当然我们也可以使用get(long timeout, TimeUnit unit)

     try {
         Integer result = (Integer) future.get(500, TimeUnit.MILLISECONDS);                     
              System.out.println(result);
     } catch (Exception e) {
         e.printStackTrace();
 }　

    由于在500ms内没有结果返回，所以抛出异常，打印异常堆栈如下

         

          当然，如果我们把超时时间设置的长一些，还是可以得到预期的结果的。

    FutureTask实现原理

        下面我们介绍一下FutureTask内部的一些实现机制。下文从以下几点叙述：

    1. 类继承结构
    2. 核心成员变量
    3. 内部状态转换
    4. 核心方法解析

    1 类继承结构

          首先我们看一下FutureTask的继承结构：

    　　　

          FutureTask实现了RunnableFuture接口，而RunnableFuture继承了Runnable和Future，也就是说FutureTask既是Runnable，也是Future。

    2 核心成员变量

        FutureTask内部定义了以下变量，以及它们的含义如下

    1 private static final int NEW          = 0; //任务新建和执行中
2 private static final int COMPLETING   = 1; //任务将要执行完毕
3 private static final int NORMAL       = 2; //任务正常执行结束
4 private static final int EXCEPTIONAL  = 3; //任务异常
5 private static final int CANCELLED    = 4; //任务取消
6 private static final int INTERRUPTING = 5; //任务线程即将被中断
7 private static final int INTERRUPTED  = 6; //任务线程已中断
    • volatile int state:表示对象状态，volatile关键字保证了内存可见性。futureTask中定义了7种状态，代表了7种不同的执行状态
    • Callable<V> callable:被提交的任务
    • Object outcome:任务执行结果或者任务异常
    • volatile Thread runner:执行任务的线程
    • volatile WaitNode waiters：等待节点，关联等待线程
    • long stateOffset:state字段的内存偏移量
    • long runnerOffset：runner字段的内存偏移量
    • long waitersOffset：waiters字段的内存偏移量

        后三个字段是配合Unsafe类做CAS操作使用的。

    3 内部状态转换

        FutureTask中使用state表示任务状态，state值变更的由CAS操作保证原子性。

        FutureTask对象初始化时，在构造器中把state置为为NEW，之后状态的变更依据具体执行情况来定。

    　  例如任务执行正常结束前，state会被设置成COMPLETING，代表任务即将完成，接下来很快就会被设置为NARMAL或者EXCEPTIONAL，这取决于调用Runnable中的call()方法是否抛出了异常。有异常则后者，反之前者。

    　　任务提交后、任务结束前取消任务，那么有可能变为CANCELLED或者INTERRUPTED。在调用cancel方法时，如果传入false表示不中断线程，state会被置为CANCELLED，反之state先被变为INTERRUPTING，后变为INTERRUPTED。

         总结下，FutureTask的状态流转过程，可以出现以下四种情况：

            1. 任务正常执行并返回。 NEW -> COMPLETING -> NORMAL

    　　  2. 执行中出现异常。NEW -> COMPLETING -> EXCEPTIONAL

            3. 任务执行过程中被取消，并且不响应中断。NEW -> CANCELLED

    　　  4. 任务执行过程中被取消，并且响应中断。 NEW -> INTERRUPTING -> INTERRUPTED　　

    4 核心方法解析

    　　接下来我们一起扒一扒FutureTask的源码。我们先看一下任务线程是怎么执行的。当任务被提交到线程池后，会执行futureTask的run()方法。

    1 public void run()

     1 public void run() {<br>        // 校验任务状态
 2         if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
 3             return;
 4         try {
 5             Callable<V> c = callable;<br>　　　　　　　// double check
 6             if (c != null && state == NEW) {
 7                 V result;
 8                 boolean ran;
 9                 try {<br>　　　　　　　　　　　　//执行业务代码
10                     result = c.call();
11                     ran = true;
12                 } catch (Throwable ex) {
13                     result = null;
14                     ran = false;
15                     setException(ex);
16                 }
17                 if (ran)
18                     set(result);
19             }
20         } finally {<br>　　　　　　  // 重置runner
21             runner = null;
22             int s = state;
23             if (s >= INTERRUPTING)
24                 handlePossibleCancellationInterrupt(s);
25         }
26     }

    翻译一下，这个方法经历了以下几步

    1. 校验当前任务状态是否为NEW以及runner是否已赋值。这一步是防止任务被取消。
    2. double-check任务状态state
    3. 执行业务逻辑，也就是c.call()方法被执行
    4. 如果业务逻辑异常，则调用setException方法将异常对象赋给outcome，并且更新state值
    5. 如果业务正常，则调用set方法将执行结果赋给outcome，并且更新state值

     我们继续往下看，setException(Throwable t)和set(V v) 具体是怎么做的

     1 protected void set(V v) {
 2         // state状态 NEW->COMPLETING
 3         if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
 4             outcome = v;
 5             // COMPLETING -> NORMAL 到达稳定状态
 6             UNSAFE.putOrderedInt(this, stateOffset, NORMAL);
 7             // 一些结束工作
 8             finishCompletion();
 9         }
10     }
11 protected void setException(Throwable t) {
12     // state状态 NEW->COMPLETING
13     if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
14         outcome = t;
15         // COMPLETING -> EXCEPTIONAL 到达稳定状态
16         UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL);
17         // 一些结束工作
18         finishCompletion();
19     }
20 }　

    code中的注释已经写的很清楚，故不翻译了。状态变更的原子性由unsafe对象提供的CAS操作保证。FutureTask的outcome变量存储执行结果或者异常对象，会由主线程返回。

    2  get()和get(long timeout, TimeUnit unit)

        任务由线程池提供的线程执行，那么这时候主线程则会阻塞，直到任务线程唤醒它们。我们通过get(long timeout, TimeUnit unit)方法看看是怎么做的　　

     1 public V get(long timeout, TimeUnit unit)
 2         throws InterruptedException, ExecutionException, TimeoutException {
 3         if (unit == null)
 4             throw new NullPointerException();
 5         int s = state;
 6         if (s <= COMPLETING &&
 7             (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
 8             throw new TimeoutException();
 9         return report(s);
10     }

     get的源码很简洁，首先校验参数，然后根据state状态判断是否超时，如果超时则异常，不超时则调用report(s)去获取最终结果。

        当 s<= COMPLETING时，表明任务仍然在执行且没有被取消。如果它为true，那么走到awaitDone方法。

        awaitDone是futureTask实现阻塞的关键方法，我们重点关注一下它的实现原理。

     1 /**
 2  * 等待任务执行完毕,如果任务取消或者超时则停止
 3  * @param timed 为true表示设置超时时间
 4  * @param nanos 超时时间
 5  * @return 任务完成时的状态
 6  * @throws InterruptedException
 7  */
 8 private int awaitDone(boolean timed, long nanos)
 9         throws InterruptedException {
10     // 任务截止时间
11     final long deadline = timed ? System.nanoTime() + nanos : 0L;
12     WaitNode q = null;
13     boolean queued = false;
14     // 自旋
15     for (;;) {
16         if (Thread.interrupted()) {
17             //线程中断则移除等待线程,并抛出异常
18             removeWaiter(q);
19             throw new InterruptedException();
20         }
21         int s = state;
22         if (s > COMPLETING) {
23             // 任务可能已经完成或者被取消了
24             if (q != null)
25                 q.thread = null;
26             return s;
27         }
28         else if (s == COMPLETING)
29             // 可能任务线程被阻塞了,主线程让出CPU
30             Thread.yield();
31         else if (q == null)
32             // 等待线程节点为空,则初始化新节点并关联当前线程
33             q = new WaitNode();
34         else if (!queued)
35             // 等待线程入队列,成功则queued=true
36             queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
37                     q.next = waiters, q);
38         else if (timed) {
39             nanos = deadline - System.nanoTime();
40             if (nanos <= 0L) {
41                 //已经超时的话,移除等待节点
42                 removeWaiter(q);
43                 return state;
44             }
45             // 未超时,将当前线程挂起指定时间
46             LockSupport.parkNanos(this, nanos);
47         }
48         else
49             // timed=false时会走到这里,挂起当前线程
50             LockSupport.park(this);
51     }
52 }

    注释里也很清楚的写明了每一步的作用，我们以设置超时时间为例，总结一下过程

    1. 计算deadline，也就是到某个时间点后如果还没有返回结果，那么就超时了。
    2. 进入自旋，也就是死循环。
    3. 首先判断是否响应线程中断。对于线程中断的响应往往会放在线程进入阻塞之前，这里也印证了这一点。
    4. 判断state值，如果>COMPLETING表明任务已经取消或者已经执行完毕，就可以直接返回了。
    5. 如果任务还在执行，则为当前线程初始化一个等待节点WaitNode，入等待队列。这里和AQS的等待队列类似，只不过Node只关联线程，而没有状态。AQS里面的等待节点是有状态的。
    6. 计算nanos，判断是否已经超时。如果已经超时，则移除所有等待节点，直接返回state。超时的话，state的值仍然还是COMPLETING。
    7. 如果还未超时，就通过LockSupprot类提供的方法在指定时间内挂起当前线程，等待任务线程唤醒或者超时唤醒。

    当线程被挂起之后，如果任务线程执行完毕，就会唤醒等待线程哦。这一步就是在finishCompletion里面做的，前面已经提到这个方法。我们再看看这个方法具体做了哪些事吧~

     1 /**
 2  * 移除并唤醒所有等待线程,执行done,置空callable
 3  * nulls out callable.
 4  */
 5 private void finishCompletion() {
 6     //遍历等待节点
 7     for (WaitNode q; (q = waiters) != null;) {
 8         if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
 9             for (;;) {
10                 Thread t = q.thread;
11                 if (t != null) {
12                     q.thread = null;
13                     //唤醒等待线程
14                     LockSupport.unpark(t);
15                 }
16                 WaitNode next = q.next;
17                 if (next == null)
18                     break;
19                 // unlink to help gc
20                 q.next = null;
21                 q = next;
22             }
23             break;
24         }
25     }
26     //模板方法,可以被覆盖
27     done();
28     //清空callable
29     callable = null;
30 }

    由代码和注释可以看出来，这个方法的作用主要在于唤醒等待线程。由前文可知，当任务正常结束或者异常时，都会调用finishCompletion去唤醒等待线程。这个时候，等待线程就可以醒来，开开心心的获得结果啦。　　

    最后我们看一下任务取消　　

    3 public boolean cancel(boolean mayInterruptIfRunning)

      注意，取消操作不一定会起作用，这里我们先贴个demo

     1 public class FutureDemo {
 2     public static void main(String[] args) {
 3         ThreadPoolExecutor executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(1);
 4         // 预创建线程
 5         executorService.prestartCoreThread();
 6 
 7         Future future = executorService.submit(new Callable<Object>() {
 8             @Override
 9             public Object call() {
10                 System.out.println("start to run callable");
11                 Long start = System.currentTimeMillis();
12                 while (true) {
13                     Long current = System.currentTimeMillis();
14                     if ((current - start) > 1000) {
15                         System.out.println("当前任务执行已经超过1s");
16                         return 1;
17                     }
18                 }
19             }
20         });
21 
22         System.out.println(future.cancel(false));
23 
24         try {
25             Thread.currentThread().sleep(3000);
26             executorService.shutdown();
27         } catch (Exception e) {
28             //NO OP
29         }
30     }
31 }

    我们多次测试后发现，出现了2种打印结果，如图

    　　　　　　　　　　　　　　　　结果1

    　　　　　　　　　　　　　　　　结果2　　　　

    第一种是任务压根没取消，第二种则是任务压根没提交成功。　

        方法签名注释告诉我们，取消操作是可能会失败的，如果当前任务已经结束或者已经取消，则当前取消操作会失败。如果任务尚未开始，那么任务不会被执行。这就解释了出现上图结果2的情况。我们还是从源码去分析cancel()究竟做了哪些事。

     1 public boolean cancel(boolean mayInterruptIfRunning) {
 2         if (state != NEW)
 3             return false;
 4         if (mayInterruptIfRunning) {
 5             if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, INTERRUPTING))
 6                 return false;
 7             Thread t = runner;
 8             if (t != null)
 9                 t.interrupt();
10             UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); // final state
11         }
12         else if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, CANCELLED))
13             return false;
14         finishCompletion();
15         return true;
16     }

    　执行逻辑如下

    1. state不为NEW时，任务即将进入终态，直接返回false表明取消操作失败。
    2. state状态为NEW，任务可能已经开始执行，也可能还未开始。
    3. mayInterruptIfRunning表明是否中断线程。若是，则尝试将state设置为INTERRUPTING，并且中断线程，之后将state设置为终态INTERRUPTED。
    4. 如果mayInterruptIfRunning=false，则不中断线程，把state设置为CANCELLED
    5. 移除等待线程并唤醒。
    6. 返回true

        可见，cancel()方法改变了futureTask的状态位，如果传入的是false并且业务逻辑已经开始执行，当前任务是不会被终止的，而是会继续执行，直到异常或者执行完毕。如果传入的是true，会调用当前线程的interrupt()方法，把中断标志位设为true。

        事实上，除非线程自己停止自己的任务，或者退出JVM，是没有其他方法完全终止一个线程的任务的。mayInterruptIfRunning=true，通过希望当前线程可以响应中断的方式来结束任务。当任务被取消后，会被封装为CancellationException抛出。

    总结

    　　总结一下，futureTask中的任务状态由变量state表示，任务状态都基于state判断。而futureTask的阻塞则是通过自旋+挂起线程实现。理解FutureTask的内部实现机制，我们使用Future时才能更加得心应手。文中掺杂着笔者的个人理解，如果有不正之处，还望读者多多指正
  • 相关阅读:
    log4net插入access自定义字段
    前端规范
    烤冷面项目进度文档
    响应式布局及bootstrap（实例）
    HTML嵌套规则
    前端规范2-CSS规范
    前端规范1-HTML规范
    入驻博客园
    .net中运用solr提升搜索效率(入门)
    .net 使用validator做数据校验
  • 原文地址：https://www.cnblogs.com/linghu-java/p/8990973.html
Copyright © 2020-2023  润新知