FutureTask 会 “吞掉“ 异常是怎么回事？需要注意些什么？

最新推荐文章于 2023-10-19 08:59:23 发布

快乐妮子

最新推荐文章于 2023-10-19 08:59:23 发布

阅读量2.4k

点赞数 3

分类专栏： java 笔记

本文链接：https://blog.csdn.net/u014240299/article/details/108849457

版权

java 同时被 2 个专栏收录

24 篇文章 3 订阅

订阅专栏

笔记

4 篇文章 0 订阅

订阅专栏

这次，没有废话，切入正题！

在Callable#call方法里，如果没有try-catch的情况下，如果call方法运行时，一旦出现异常，那么该异常会被Future所接收到，且只有调用 Future # get方法才会抛出。也就是说，如果你不调用get方法，做些异常处理的话，真的发现不了问题发生在哪？这种情况，就好像是异常被"吞掉" 了。

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("===> 开始执行callable");
        int i = 1 / 0; //异常的地方
        return "callable的结果";
    }
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CallableAndRunnableTest {

    public static void main(String[] args) {
        System.out.println(" =========> main start ");
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 5, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));
        Future<String> submit = threadPoolExecutor.submit(new MyCallable());
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(" =========> main end ");
    }
}

运行结果：

 =========> main start 
 ===> 开始执行callable
 =========> main end

懵逼了，竟然那么大的异常，都没有发现。试试Runnable 会怎样呢，

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("====》 开始执行runnable ");
        int i = 1 / 0; //异常的地方
    }
}

=========> main start 
====》 开始执行runnable 
Exception in thread "pool-1-thread-1" java.lang.ArithmeticException: / by zero
	at com.yuki.test.thread.MyRunnable.run(MyRunnable.java:7)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)
 =========> main end

看来Runnable很符合我们的胃口嘛，要的就是异常给我抛出来。这样不用挠头找Bug的根源在哪了啊。

回过头，看看Callable 怎么就把异常“吞掉”了呢？答案就在源码里，别着急，慢慢找哈。

先进入 threadPoolExecutor.submit(new MyCallable()) 的源码，跳转到了 AbstractExecutorService

 /**
     * @throws RejectedExecutionException {@inheritDoc}
     * @throws NullPointerException       {@inheritDoc}
     */
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        //把Callable赋值给FutureTask，这行代码，我是不是可以理解成把对象封装成FutureTask对象
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

接着，进入newTaskFor(task) 看看干了些啥事情吧~ 最后跟踪到FutureTask.java 的构造方法来了。

   public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

看上去，好像就是FutureTask的成员变量初始化，对吧？一个Callable ，一个是状态标识（zhi）。那回到前面，FutrueTask 可以直接赋值给 RunableFuture<T> ？那估计是个接口，看看源码确认下：

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

意料之中啊， RunableFuture<T> 就是个接口，等等，发现它继承了Runnable 接口，那这里就必须要看下 FutureTask 里的run方法是不是和构造时的Callable 有关系呢？所以 FutureTask 的run方法，必须要看下了。记得，重点关注怎么把异常吞掉了的？

 public void run() {
        // 状态不属于初始状态的情况下，不进行后续逻辑处理
        // 那也就是run 方法只能执行一次
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
               	// 
                boolean ran;
                try {
                    // 执行 Callable 里的 call 方法 ，将结果存入result变量中
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                     // call 方法异常 ， 记录下异常结果
                    setException(ex);
                }
                // call 方法正常执行完毕 ，进行结果存储
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

接下去，就要重点关注，如果存储正常结果set(result) 和 setException(ex) 的了。

 protected void setException(Throwable t) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

    protected void set(V v) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = v;
            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
            finishCompletion();
        }
    }

这两个方法，乍一眼还以为一样的代码呢？都做了一个操作，就是将正常结果result 和异常结果 exception 都赋值给了 outcome 这个变量。

  /** The result to return or exception to throw from get() */
    private Object outcome; // non-volatile, protected by state reads/writes

其它的几个步骤，就是更新下 Task 的状态，以及通知其它的等待线程，告诉它们，当前这个Task 已经完成了。

这里有必须看下Task的结束时的状态，如果正常结束，状态为 NORMAL ，异常结果，状态为EXCEPTIONAL 。看下几个状态的定义，如下：

  private volatile int state;
    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;

好了，到这里，就大概看完了FutureTask#run 方法的实现了。

这里，我们停一下，快接近答案了，回忆下，我们是不是通过Future#get 方法获取到结果的，所以现在只要研究下get方法。由于FutureTask 还实现了 Future 接口，在这个接口里就定义了 get 方法。

在这里插入图片描述
翻阅FutureTask#get

 /**
     * @throws CancellationException {@inheritDoc}
     */
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        // NORMAL(2) 、EXCEPTIONAL(3) 都大于 COMPLETING（1）,所以Task结束之后，不会走该if
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        // 重点： 返回结果
        return report(s);
    }

	private V report(int s) throws ExecutionException {
       // 之前正常结果或者异常都存放在Object outcomme 中了
        Object x = outcome;
        // 正常返回
        if (s == NORMAL)
            return (V)x;
        // EXCEPTIONAL(3) 小于 CANCELLED(4) ，所以不会走该if分支，直接后续的throw 抛异常的逻辑
        if (s >= CANCELLED)
            throw new CancellationException();
        // 不等于NORMAL 且 大于等于 CANCELLED  ,  再结合 调用 report(int s ) 之前也做了state 的过滤
        //到这一步，那只能是EXCEPTIONAL(3) 
        throw new ExecutionException((Throwable)x);
    }

哇塞，终于找到了答案，给自己鼓个掌！！！

总结：

submit(Callable callable ) 其实就是通过FutureTask 对 Callable#call 进行一层try-catch 操作，正常或者异常的执行结果都存入到Future的Object outcome 内部成员变量中。在FutureTask#get获取执行结果的时候，依据内部执行状态标识来选择以哪种方式返回outcome , 如果是NORMAL 状态，就直接返回接口，如果是EXCEPTIONAL 状态就以throw ExecutionException 的方式返回。
FutureTask#get方法是一个阻塞方法，可以自行从上面贴出源码找答案。
不论Runnable#run() 还是Callable#call() 方法，都是普通方法，那为啥感觉有点与众不同？emm… 拿Runnable 来说，主要是因为和Thread 挂钩，实现了线程的执行方法体。如果不看Thread ，不也就只是个接口的定义方法嘛？
如果你不想调用FutureTask#get 方法，建议使用Runnable 或者在Callable的call方法自行try-catch一把。

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        try{
             System.out.println("===> 开始执行callable");
        	int i = 1 / 0; //异常的地方
        }catch(Exception e){
            //异常处理
             System.out.println("===> 糟啦 ， callable 执行异常： ");
        }       
        return "callable的结果";
    }
}