java-源码解读-线程池提交之execute和submit有何不同

先上测试用例

package com.phl.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @Title:SubmitExecuteMain
 * @Description:
 * @Copyright:中国电信爱wifi运营中心
 * @author:panhl
 * @date 2017/9/26 0026 10:34
 */
public class SubmitExecuteMain {
    public static void main(String[] args) throws Exception{
        submit();
        submitWithGet();
        execute();
    }
    private static void submitWithGet() throws Exception{
        ExecutorService service= Executors.newSingleThreadExecutor();
        Future future=service.submit(new Runnable() {
            @Override
            public void run() {
                int i=7/0;
            }
        });

    service.shutdown();
    future.get(); 
}

private static void submit(){ ExecutorService service= Executors.newSingleThreadExecutor(); service.submit(new Runnable() { @Override public void run() { int i=7/0; } }); service.shutdown(); } private static void execute(){ ExecutorService service= Executors.newSingleThreadExecutor(); service.execute(new Runnable() { @Override public void run() { int i=7/0; } }); service.shutdown(); }}

先下结论

1.对返回值的处理不同
execute方法不关心返回值。
submit方法有返回值，Future。
2.对异常的处理不同
excute方法会抛出异常。
sumbit方法不会抛出异常。除非你调用Future.get()。

再看原理

当我们调用ExecutorService的submit的时候，其实是调用了
AbstractExecutorService.submit方法。直接看源码：

 public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
 }

 从上面的代码可以看出 execute和sumbit方法的不同在于这一行封装：

 RunnableFuture<Void> ftask = newTaskFor(task, null);

 这就是关键所在。

 先看execute方法

 当我们调用execute时，以ThreadPoolExecutor实现为例，他就是调用了ThreadPoolExecutor的execute方法。

  public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }  

这里不分析 execute方法内部实现，我想说的是ExecutorService的execute方法提交的任务被原模原样的的转交给了实现类ThreadPoolExecutor的execute方法。

也就是说原来提交的是Runnable，执行的也是Runnable.

具体提交任务流程不在这里作分析，最后直接看任务的执行代码：ThreadPoolExecutor.runWorker

    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

真正执行的地方在task.run这一行，task 就是原模原样提交的Runnable,也就是执行了Runnable.run方法。 有异常就抛异常。

再看sumbit方法

sumbit方法的不同之处在于上面提到的那一行,对Runnable的封装。

 RunnableFuture<Void> ftask = newTaskFor(task, null);

直接看newTaskFor方法把 Runnable封装成了什么东西：

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
}
public FutureTask(Runnable runnable, V result) {
      this.callable = Executors.callable(runnable, result);
      this.state = NEW;       // ensure visibility of callable
}

Runnable转变过程：
Runnable-----newTaskFor----->new FutureTask()------->FutureTask
任务的转变过程：
Runnable.run()-----Executors.callable(runnable, result)------->Callable.call()
通过上面两个方法，Runnable已经转变成了FutureTask。

关于FutureTask ,请参考我的另一篇博客：java-源码解读-FutureTask 

通过上面对execute方法的分析，我们知道runWorker 方法中那句task.run()其实也就是FutureTask.run()了。

直接看FutureTask.run()都干了什么：

    public void 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 {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            runner = null;
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

代码很清楚，run方法中真正执行任务的地方为c.call(),也就是调用Callable.call(),当c.call()发生异常时 catch了,并调用了setExcetion方法：

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

setException把抛出的异常赋值给了outcome，outcome就是Futer.get() 的返回结果。
所以就有了开始的结论，submit提交任务时不会有异常，因为异常被当作结果返回了。

要想submit方法也抛出异常,可以调用 Future.get(); Future的get 方法如下：

    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }  
    private V report(int s) throws ExecutionException {
        Object x = outcome;
        if (s == NORMAL)
            return (V)x;
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }