submit和execute的区别

Posted 2023-04-06 zqlmianshi

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了submit和execute的区别相关的知识，希望对你有一定的参考价值。

线程池的submit()和execute()方法都可以用于向线程池提交任务，但它们有一些区别：

返回值不同：submit()方法会返回一个Future对象，可以通过Future对象获取任务的执行结果；而execute()方法没有返回值，无法获取任务的执行结果。
异常处理不同：submit()方法可以处理任务抛出的异常，可以通过Future对象的get()方法获取异常信息；而execute()方法无法处理任务抛出的异常，需要在Runnable的run()方法中进行处理。
可以提交的任务类型不同：submit()方法可以接收Callable类型的任务，即具有返回值的任务，而execute()方法只能接收Runnable类型的任务，即无返回值的任务。

综上所述，如果需要获取任务的执行结果或处理任务抛出的异常，应该使用submit()方法；如果只需要提交无返回值的任务，可以使用execute()方法。

execute和submit的区别与联系

execute和submit都属于线程池的方法，execute只能提交Runnable类型的任务，而submit既能提交Runnable类型任务也能提交Callable类型任务。

execute会直接抛出任务执行时的异常，submit会吃掉异常，可通过Future的get方法将任务执行时的异常重新抛出。

execute所属顶层接口是Executor,submit所属顶层接口是ExecutorService，实现类ThreadPoolExecutor重写了execute方法,抽象类AbstractExecutorService重写了submit方法。

submit和execute由于参数不同有四种实现形式，如下所示，本文主要研究这四种形式在各自使用场景下的区别和联系


<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);
void execute(Runnable command);

关于Runnable和Callable任务如果你还存在疑惑，建议你先看看我的上篇文章Runnable和Callable的区别和联系。

测试代码的整体框架如下：


import java.util.concurrent.*;
 
public class TestSubmitAndExecute 
    static ExecutorService executor = Executors.newCachedThreadPool();
 
    public static void main(String[] args) 
        initExecutors();
        /**put test codes here*/
 
 
        /***/
        waitToTerminated();
 
    
 
 
    private static void initExecutors() 
        if (executor.isTerminated()) 
            executor = Executors.newCachedThreadPool();
        
    
 
    private static void waitToTerminated() 
        executor.shutdown();
        while (!executor.isTerminated()) 
        
    
 
    /**
     * 测试 submit(Callable<T> task)
     *
     * @param callable
     * @param <T>
     * @return
     */
    public static <T> T testSubmitCallable(Callable callable) 
        Future<T> future = executor.submit(callable);
        T result = null;
        try 
            result = future.get();
         catch (InterruptedException e) 
            e.printStackTrace();
         catch (ExecutionException e) 
            e.printStackTrace();
        
        return result;
    
 
    /**
     * 测试submit(Runnable task, T result)
     *
     * @param runnable
     * @param t
     * @param <T>
     * @return
     */
    public static <T> T testSubmitRunnable(Runnable runnable, T t) 
        Future<T> future = executor.submit(runnable, t);
        T result = null;
        try 
            result = future.get();
         catch (InterruptedException e) 
            e.printStackTrace();
         catch (ExecutionException e) 
            e.printStackTrace();
        
        return result;
    
 
    /**
     * 测试 submit(Runnable task)
     * submit提交Runnable任务会默认返回null
     *
     * @param runnable
     * @return
     */
    public static Object testSubmitRunnable(Runnable runnable) 
        Future<?> future = executor.submit(runnable);
        Object v = null;
        try 
            v = future.get();
         catch (InterruptedException e) 
            e.printStackTrace();
         catch (ExecutionException e) 
            e.printStackTrace();
        
        return v;
    
 
    /**
     * 测试 execute(Runnable command)
     * execute会直接抛出异常，submit只有通过调用Future对象的get方法才能获取异常
     *
     * @param runnable
     */
    public static void testExecuteRunnable(Runnable runnable) 
        executor.execute(runnable);

这个测试框架提供了4个静态方法用来测试submit和execute总共包含的四种表现形式，除此之外提供initExecutors用于提前检测线程池是否终止，若终止则初始化，waitToTerminated方法用于关闭线程池，并阻塞到线程池终止为止。

除了测试框架之外提供了4个不同的任务，分别测试Callable和Runnable在抛异常时的表现形式。


class CallableTask implements Callable<Integer> 
    @Override
    public Integer call() throws Exception 
        int sum = 0;
        for (int i = 0; i < 520; i++) 
            sum += i;
        
        return sum;
    
 
/**
 * 会抛异常的CallableTask
 */
class ExceptionCallableTask implements Callable<Boolean> 
    public Boolean call() throws Exception 
        int num = 1 / 0;
        return false;
    
 
class RunnableTask implements Runnable 
    @Override
    public void run() 
        System.out.println("I am a runnable task");
    
 
/**
 * 会抛异常的RunnableTask
 */
class ExceptionRunableTask implements Runnable 
    @Override
    public void run() 
        int num = 1 / 0;

整体结构搭起来，下来就是研究具体差异的时刻了。

1）首先研究Future<?> submit(Runnable task)和void execute(Runnable command)，这两个方法都是执行Runnable类型任务，前者有返回值，但是返回值为null，后者无返回值。


    public static void main(String[] args) 
        initExecutors();
        /**put test codes here*/
        Object object = testSubmitRunnable(new RunnableTask());
        System.out.println(object);
 
        testExecuteRunnable(new RunnableTask());
 
        /***/
        waitToTerminated();

很容易观察控制台输出如下：


I am a runnable task
null
I am a runnable task

可以看出submit执行Runnable类型任务时默认返回值为null。如果我们需要submit在提交Runnable任务可以返回非空，就需要用到submit的另外一个重载的方法：<T> Future<T> submit(Runnable task, T result);

2）submit(Runnable task, T result) 方法可以使submit执行完Runnable任务后返回指定的返回值。

main方法如下：


    public static void main(String[] args) 
        initExecutors();
        /**put test codes here*/
//        Object object = testSubmitRunnable(new RunnableTask());
//        System.out.println(object);
//
//        testExecuteRunnable(new RunnableTask());
 
        Integer i = testSubmitRunnable(new RunnableTask(), 3);
        System.out.println(i);
 
        Boolean bool = testSubmitRunnable(new RunnableTask(), true);
        System.out.println(bool);
 
        String str = testSubmitRunnable(new RunnableTask(), "你好吗");
        System.out.println(str);
 
 
        /***/
        waitToTerminated();

控制台输出：


I am a runnable task
3
I am a runnable task
true
I am a runnable task
你好吗

可以看出我们输入的什么参数，任务执行完毕后就返回什么参数。

3）submit(Callable<T> task)这个方法没什么好说的，用来提交Callable类型任务，返回值由call方法决定。

main方法如下：


    public static void main(String[] args) 
        initExecutors();
        /**put test codes here*/
//        Object object = testSubmitRunnable(new RunnableTask());
//        System.out.println(object);
//
//        testExecuteRunnable(new RunnableTask());
 
//        Integer i = testSubmitRunnable(new RunnableTask(), 3);
//        System.out.println(i);
//
//        Boolean bool = testSubmitRunnable(new RunnableTask(), true);
//        System.out.println(bool);
//
//        String str = testSubmitRunnable(new RunnableTask(), "你好吗");
//        System.out.println(str);
 
        Object o = testSubmitCallable(new CallableTask());
        System.out.println(o);
 
        /***/
        waitToTerminated();

CallableTask的执行逻辑是计算0到520之间的所有整数之和，所以控制台输出：

4）关于execute和submit遭遇异常的表现

execute直接将任务执行时期的异常抛出，main方法和控制台打印分别如下：


    public static void main(String[] args) 
        initExecutors();
        /**put test codes here*/
//        Object object = testSubmitRunnable(new RunnableTask());
//        System.out.println(object);
//
//        testExecuteRunnable(new RunnableTask());
 
//        Integer i = testSubmitRunnable(new RunnableTask(), 3);
//        System.out.println(i);
//
//        Boolean bool = testSubmitRunnable(new RunnableTask(), true);
//        System.out.println(bool);
//
//        String str = testSubmitRunnable(new RunnableTask(), "你好吗");
//        System.out.println(str);
 
//        Object o = testSubmitCallable(new CallableTask());
//        System.out.println(o);
 
        testExecuteRunnable(new ExceptionRunableTask());
 
        /***/
        waitToTerminated();


Exception in thread "pool-1-thread-1" java.lang.ArithmeticException: / by zero
  at ExceptionRunableTask.run(TestRunnableAndCallable.java:38)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
  at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
  at java.lang.Thread.run(Thread.java:745)

submit比较特殊，如果没有通过Future.get来获取结算结果，则吃掉异常。先将测试方法稍做调整，修改成如下形式：


    /**
     * 测试 submit(Callable<T> task)
     *
     * @param callable
     * @param <T>
     * @return
     */
    public static <T> T testSubmitCallable(Callable callable) 
        Future<T> future = executor.submit(callable);
        T result = null;
        /*
        try 
            result = future.get();
         catch (InterruptedException e) 
            e.printStackTrace();
         catch (ExecutionException e) 
            e.printStackTrace();
        
        */
        return result;

当我们在main方法添加如下代码时，控制台其实没有打印任何异常


    public static void main(String[] args) 
        initExecutors();
        /**put test codes here*/
//        Object object = testSubmitRunnable(new RunnableTask());
//        System.out.println(object);
//
//        testExecuteRunnable(new RunnableTask());
 
//        Integer i = testSubmitRunnable(new RunnableTask(), 3);
//        System.out.println(i);
//
//        Boolean bool = testSubmitRunnable(new RunnableTask(), true);
//        System.out.println(bool);
//
//        String str = testSubmitRunnable(new RunnableTask(), "你好吗");
//        System.out.println(str);
 
//        Object o = testSubmitCallable(new CallableTask());
//        System.out.println(o);
 
//        testExecuteRunnable(new ExceptionRunableTask());
 
        testSubmitCallable(new ExceptionCallableTask());
 
        /***/
        waitToTerminated();

如果将testSubmitCallable代码中被注释的部分取消注释，则可以看到异常信息如下：


java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero
    at java.util.concurrent.FutureTask.report(FutureTask.java:122)
  at java.util.concurrent.FutureTask.get(FutureTask.java:192)
 at TestSubmitAndExecute.testSubmitCallable(TestSubmitAndExecute.java:58)
    at TestSubmitAndExecute.main(TestSubmitAndExecute.java:28)
Caused by: java.lang.ArithmeticException: / by zero
    at ExceptionCallableTask.call(TestRunnableAndCallable.java:20)
  at ExceptionCallableTask.call(TestRunnableAndCallable.java:18)
  at java.util.concurrent.FutureTask.run(FutureTask.java:266)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
 at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
 at java.lang.Thread.run(Thread.java:745)

关于execute和submit的简单研究到此结束，谢谢观看。

原文地址：https://www.jianshu.com/p/29610984f1dd

以上是关于submit和execute的区别的主要内容，如果未能解决你的问题，请参考以下文章

ThreadPoolExecutor线程池execute和submit的区别

多线程ExecutorService中submit和execute区别

并发编程之submit和execute区别

execute和submit的区别

ExecutorService中submit和execute区别

ExecutorService.submit()与Executor.execute()的区别