Java线程池execute和submit的区别

前言

ThreadPoolExecutor提供了两种方法来执行异步任务，分别是execute和submit，也是日常开发中经常使用的方法，那么它俩有什么区别呢？

语义不同

首先是语义上的不同。execute声明在Executor接口，它接受一个Runnable类型的入参，且没有返回值，代表它可以异步执行一个没有返回结果的异步任务，你甚至不知道这个任务什么时候执行完毕。

java 复制代码

public interface Executor {
  void execute(Runnable command);
}

而submit声明在ExecutorService，且有多个重载方法，最明显的区别就是submit方法均有Future返回值。Future代表未来结果的一个占位符，可以通过它拿到异步任务的执行结果，如果异步任务执行失败，也可以通过它拿到异常信息。

所以，下面三个方法的区别是：方法1的入参是Runnable没有返回结果，所以返回的Future是也拿不到结果的，只能判断异步任务是否执行完毕以及是否执行异常；方法2返回的Future可以拿到结果，值是第二个入参；方法3也可以拿到结果，值就是入参Callable返回的结果。

java 复制代码

public interface ExecutorService extends Executor {
  [1] Future<?> submit(Runnable task);
  [2] <T> Future<T> submit(Runnable task, T result);
  [3] <T> Future<T> submit(Callable<T> task);
}

综上所述，execute和submit最明显的一个区别就是语义上的不同。execute用来执行没有返回结果的异步任务，且调用方不关心任务的执行结果；而submit用来执行有返回结果的异步任务，适用于调用方关心执行结果和异步任务执行有返回值的场景。

异常处理不同

execute和submit第二个区别是：异步任务执行异常时的处理不同。execute遇到异常会直接抛出来，而submit会默默吃掉异常。

如下示例，execute会把除0异常的堆栈打印出来，而submit则没有打印任何信息。

java 复制代码

public static void main(String[] args) throws Exception {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        executor.execute(() -> {
            System.err.println("execute result:");
            System.err.println(1 / 0);
        });
        executor.submit(() -> {
            System.err.println("submit result:");
            System.err.println(1 / 0);
        });
    }

java 复制代码

execute result:
Exception in thread "pool-1-thread-1" java.lang.ArithmeticException: / by zero
	at ExecutorDemo2.lambda$main$0(ExecutorDemo2.java:18)
	at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1136)
	at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:635)
	at java.base/java.lang.Thread.run(Thread.java:840)
submit result:

你可能会觉得疑惑，submit凭什么要默默吃掉异常，任务执行出错为什么不通知调用方呢？

事实上，submit针对异常的处理方式正和它的语义有关，它并没有吃掉异常，而是它认为方法执行异常也是结果的一部分，别忘了它是有Future返回值的，只不过它并没有粗暴的直接抛出异常，而是把异常记录在了Future返回值里面。如果要关心submit提交的异步任务的执行情况，可以通过下面这种方式：

java 复制代码

Future<?> future = executor.submit(() -> {
    System.err.println("submit result:");
    System.err.println(1 / 0);
});
try {
    future.get();
    System.err.println("正常执行");
} catch (Exception e) {
    System.err.println("原来执行异常了:" + e.getMessage());
}

异常线程销毁重建

execute和submit第三个区别是：execute面对异常线程会销毁重建，而submit会继续复用异常线程。

看下面的例子，创建一个固定3个线程的线程池，先分别execute执行2个正常的任务和1个异常任务，sleep一会再次执行三个任务，我们发现3号线程因为执行异常被销毁了，线程池重新启动了4号线程。如果调用submit，则始终是一开始创建的三个线程在工作，不会出现线程的销毁和重建情况。

java 复制代码

public static void main(String[] args) throws Exception {
    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 3, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new ThreadPoolExecutor.CallerRunsPolicy());
    executor.execute(new Task(false));
    executor.execute(new Task(false));
    executor.execute(new Task(true));

    Thread.sleep(1000);
    System.err.println("===============");
    for (int i = 0; i < 3; i++) {
        executor.execute(new Task(false));
    }
}

static class Task implements Runnable {
    private boolean throwException;

    public Task(boolean throwException) {
        this.throwException = throwException;
    }

    @SneakyThrows
    @Override
    public void run() {
        if (throwException) {
            System.err.println("error:" + Thread.currentThread().getName());
            throw new RuntimeException();
        }
        Thread.sleep(1);
        System.err.println("task:" + Thread.currentThread().getName());
    }
}

java 复制代码

error:pool-1-thread-3
task:pool-1-thread-2
task:pool-1-thread-1
Exception in thread "pool-1-thread-3" java.lang.RuntimeException
	at ExecutorDemo$Task.run(ExecutorDemo.java:36)
	at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1136)
	at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:635)
	at java.base/java.lang.Thread.run(Thread.java:840)
===============
task:pool-1-thread-1
task:pool-1-thread-4
task:pool-1-thread-2

源码浅析

最后，从源码层面看看导致execute和submit区别的原因。

execute方法道尽了线程池的工作流程，如果工作线程数小于核心线程数，面对提交的任务会创建新线程去执行，否则尝试入队，队列满则继续创建线程直到最大线程数。

java 复制代码

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

在线程池里，线程会被封装成Worker对象，它的run方法是个while循环，不停的从任务队列workQueue里面取出异步任务并执行，不过它在执行任务时，如果遇到异常，会直接抛出来。并且在finally里面会把异常线程从workers里面移除，后续当工作线程数小于核心线程数时又会继续创建新的线程。

java 复制代码

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock();
    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);
                try {
                    task.run();
                    afterExecute(task, null);
                } catch (Throwable ex) {
                    afterExecute(task, ex);
                    throw ex; // 直接抛出异常
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

而submit之所以不会抛出异常，是因为它对提交的任务进行了一层封装，Runnable封装成了FutureTask：

java 复制代码

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

FutureTask就是Future的实现类，它重写了run方法，对异常进行了捕获，如果发生异常会把异常记录下来，而不是直接抛出，调用者可以通过Future来获得异常信息。

java 复制代码

public void run() {
    if (state != NEW ||
        !RUNNER.compareAndSet(this, 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);
    }
}

尾巴

execute和submit都可以执行异步任务，但是有三大区别，分别是：1.语义上的区别，是否关心任务的执行情况和返回结果；2.遇到遇到是直接抛出还是先记录下来；3.异常线程是销毁重建还是继续复用。在源码层面，本质上submit只是针对提交的任务又做了一层包装，FutureTask重写了run()捕获了异常信息并记录了下来，方便调用者从Future里面拿到执行结果。