`

ExecutorService中execute()和submit()的区别

 
阅读更多
在Java5之后，并发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后，通过Executor来启动线程比用Thread的start()更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。
 
一、创建任务
 
任务就是一个实现了Runnable接口的类。
创建的时候实run方法即可。
 
二、执行任务
 
通过java.util.concurrent.ExecutorService接口对象来执行任务，该接口对象通过工具类java.util.concurrent.Executors的静态方法来创建。
 
Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。
 
ExecutorService提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。 可以关闭 ExecutorService，这将导致其停止接受新任务。关闭后，执行程序将最后终止，这时没有任务在执行，也没有任务在等待执行，并且无法提交新任务。
            executorService.execute(new TestRunnable());
 
1、创建ExecutorService
通过工具类java.util.concurrent.Executors的静态方法来创建。
Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。
 
比如，创建一个ExecutorService的实例，ExecutorService实际上是一个线程池的管理工具：
        ExecutorService executorService = Executors.newCachedThreadPool();
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        ExecutorService executorService = Executors.newSingleThreadExecutor();
 
2、将任务添加到线程去执行
当将一个任务添加到线程池中的时候，线程池会为每个任务创建一个线程，该线程会在之后的某个时刻自动执行。
 
三、关闭执行服务对象
        executorService.shutdown();
 
四、综合实例
 
package concurrent; 

import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 

/** 
* Created by IntelliJ IDEA. 
* 
* @author leizhimin 2008-11-25 14:28:59 
*/
publicclass TestCachedThreadPool { 
        publicstaticvoid main(String[] args) { 
//                ExecutorService executorService = Executors.newCachedThreadPool();
                ExecutorService executorService = Executors.newFixedThreadPool(5);
//         ExecutorService executorService = Executors.newSingleThreadExecutor();

                for (int i = 0; i < 5; i++) { 
                        executorService.execute(new TestRunnable()); 
                        System.out.println("************* a" + i + " *************"); 
                } 
                executorService.shutdown(); 
        } 
} 

class TestRunnable implements Runnable { 
        publicvoid run() { 
                System.out.println(Thread.currentThread().getName() + "线程被调用了。"); 
                while (true) { 
                        try { 
                                Thread.sleep(5000); 
                                System.out.println(Thread.currentThread().getName()); 
                        } catch (InterruptedException e) { 
                                e.printStackTrace(); 
                        } 
                } 
        } 
}
 
运行结果：
************* a0 ************* 
************* a1 ************* 
pool-1-thread-2线程被调用了。 
************* a2 ************* 
pool-1-thread-3线程被调用了。 
pool-1-thread-1线程被调用了。 
************* a3 ************* 
************* a4 ************* 
pool-1-thread-4线程被调用了。 
pool-1-thread-5线程被调用了。 
pool-1-thread-2 
pool-1-thread-1 
pool-1-thread-3 
pool-1-thread-5 
pool-1-thread-4 
pool-1-thread-2 
pool-1-thread-1 
pool-1-thread-3 
pool-1-thread-5 
pool-1-thread-4 
     ......
 
 
五、获取任务的执行的返回值
在Java5之后，任务分两类：一类是实现了Runnable接口的类，一类是实现了Callable接口的类。两者都可以被ExecutorService执行，但是Runnable任务没有返回值，而Callable任务有返回值。并且Callable的call()方法只能通过ExecutorService的(<T> task) 方法来执行，并且返回一个 <T><T>，是表示任务等待完成的 Future。
 
public interface Callable<V>
返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。
Callable 接口类似于，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。
类包含一些从其他普通形式转换成 Callable 类的实用方法。
 
 
Callable中的call()方法类似Runnable的run()方法，就是前者有返回值，后者没有。
 
当将一个Callable的对象传递给ExecutorService的submit方法，则该call方法自动在一个线程上执行，并且会返回执行结果Future对象。
 
同样，将Runnable的对象传递给ExecutorService的submit方法，则该run方法自动在一个线程上执行，并且会返回执行结果Future对象，但是在该Future对象上调用get方法，将返回null。
 
遗憾的是，在Java API文档中，这块介绍的很糊涂，估计是翻译人员还没搞清楚的缘故吧。或者说是注释不到位。下面看个例子：
 
import java.util.ArrayList; 
import java.util.List; 
import java.util.concurrent.*; 

/** 
* Callable接口测试 
* 
* @author leizhimin 2008-11-26 9:20:13 
*/
publicclass CallableDemo { 
        publicstaticvoid main(String[] args) { 
                ExecutorService executorService = Executors.newCachedThreadPool(); 
                List<Future<String>> resultList = new ArrayList<Future<String>>(); 

                //创建10个任务并执行
                for (int i = 0; i < 10; i++) { 
                        //使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中
                        Future<String> future = executorService.submit(new TaskWithResult(i)); 
                        //将任务执行结果存储到List中
                        resultList.add(future); 
                } 

                //遍历任务的结果
                for (Future<String> fs : resultList) { 
                        try { 
                                System.out.println(fs.get());     //打印各个线程（任务）执行的结果
                        } catch (InterruptedException e) { 
                                e.printStackTrace(); 
                        } catch (ExecutionException e) { 
                                e.printStackTrace(); 
                        } finally { 
                                //启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。
                                executorService.shutdown(); 
                        } 
                } 
        } 
} 


class TaskWithResult implements Callable<String> { 
        privateint id; 

        public TaskWithResult(int id) { 
                this.id = id; 
        } 

        /** 
         * 任务的具体过程，一旦任务传给ExecutorService的submit方法，则该方法自动在一个线程上执行。 
         * 
         * @return 
         * @throws Exception 
         */
        public String call() throws Exception { 
                System.out.println("call()方法被自动调用,干活！！！             " + Thread.currentThread().getName()); 
                //一个模拟耗时的操作
                for (int i = 999999; i > 0; i--) ; 
                return"call()方法被自动调用，任务的结果是：" + id + "    " + Thread.currentThread().getName(); 
        } 
}
 
运行结果：
call()方法被自动调用,干活！！！             pool-1-thread-1 
call()方法被自动调用,干活！！！             pool-1-thread-3 
call()方法被自动调用,干活！！！             pool-1-thread-4 
call()方法被自动调用,干活！！！             pool-1-thread-6 
call()方法被自动调用,干活！！！             pool-1-thread-2 
call()方法被自动调用,干活！！！             pool-1-thread-5 
call()方法被自动调用，任务的结果是：0    pool-1-thread-1 
call()方法被自动调用，任务的结果是：1    pool-1-thread-2 
call()方法被自动调用,干活！！！             pool-1-thread-2 
call()方法被自动调用,干活！！！             pool-1-thread-6 
call()方法被自动调用,干活！！！             pool-1-thread-4 
call()方法被自动调用，任务的结果是：2    pool-1-thread-3 
call()方法被自动调用,干活！！！             pool-1-thread-3 
call()方法被自动调用，任务的结果是：3    pool-1-thread-4 
call()方法被自动调用，任务的结果是：4    pool-1-thread-5 
call()方法被自动调用，任务的结果是：5    pool-1-thread-6 
call()方法被自动调用，任务的结果是：6    pool-1-thread-2 
call()方法被自动调用，任务的结果是：7    pool-1-thread-6 
call()方法被自动调用，任务的结果是：8    pool-1-thread-4 
call()方法被自动调用，任务的结果是：9    pool-1-thread-3 

Process finished with exit code 0
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

因为之前一直是用的execute方法，最近有个情况需要用到submit方法，所以研究了下。

三个区别：

1、接收的参数不一样

2、submit有返回值，而execute没有

Method submit extends base method Executor.execute by creating and returning a Future that can be used to cancel execution and/or wait for completion. 

用到返回值的例子，比如说我有很多个做validation的task，我希望所有的task执行完，然后每个task告诉我它的执行结果，是成功还是失败，如果是失败，原因是什么。然后我就可以把所有失败的原因综合起来发给调用者。

个人觉得cancel execution这个用处不大，很少有需要去取消执行的。

而最大的用处应该是第二点。

3、submit方便Exception处理

There is a difference when looking at exception handling. If your tasks throws an exception and if it was submitted with execute this exception will go to the uncaught exception handler (when you don't have provided one explicitly, the default one will just print the stack trace to System.err). If you submitted the task with submit any thrown exception, checked or not, is then part of the task's return status. For a task that was submitted with submit and that terminates with an exception, the Future.get will rethrow this exception, wrapped in an ExecutionException.

意思就是如果你在你的task里会抛出checked或者unchecked exception，而你又希望外面的调用者能够感知这些exception并做出及时的处理，那么就需要用到submit，通过捕获Future.get抛出的异常。

 

比如说，我有很多更新各种数据的task，我希望如果其中一个task失败，其它的task就不需要执行了。那我就需要catch Future.get抛出的异常，然后终止其它task的执行，代码如下：

51cto上有一篇非常好的文章“Java5并发学习”（http://lavasoft.blog.51cto.com/62575/115112），下面的代码是基于它之上修改的。

 

[java] view plaincopy
  1. import java.util.ArrayList;  
  2. import java.util.List;  
  3. import java.util.Random;  
  4. import java.util.concurrent.Callable;  
  5. import java.util.concurrent.ExecutionException;  
  6. import java.util.concurrent.ExecutorService;  
  7. import java.util.concurrent.Executors;  
  8. import java.util.concurrent.Future;  
  9.   
  10. public class ExecutorServiceTest {  
  11.     public static void main(String[] args) {  
  12.         ExecutorService executorService = Executors.newCachedThreadPool();  
  13.         List<Future<String>> resultList = new ArrayList<Future<String>>();  
  14.   
  15.         // 创建10个任务并执行  
  16.         for (int i = 0; i < 10; i++) {  
  17.             // 使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中  
  18.             Future<String> future = executorService.submit(new TaskWithResult(i));  
  19.             // 将任务执行结果存储到List中  
  20.             resultList.add(future);  
  21.         }  
  22.         executorService.shutdown();  
  23.   
  24.         // 遍历任务的结果  
  25.         for (Future<String> fs : resultList) {  
  26.             try {  
  27.                 System.out.println(fs.get()); // 打印各个线程（任务）执行的结果  
  28.             } catch (InterruptedException e) {  
  29.                 e.printStackTrace();  
  30.             } catch (ExecutionException e) {  
  31.                 executorService.shutdownNow();  
  32.                 e.printStackTrace();  
  33.                 return;  
  34.             }  
  35.         }  
  36.     }  
  37. }  
  38.   
  39. class TaskWithResult implements Callable<String> {  
  40.     private int id;  
  41.   
  42.     public TaskWithResult(int id) {  
  43.         this.id = id;  
  44.     }  
  45.   
  46.     /** 
  47.      * 任务的具体过程，一旦任务传给ExecutorService的submit方法，则该方法自动在一个线程上执行。 
  48.      *  
  49.      * @return 
  50.      * @throws Exception 
  51.      */  
  52.     public String call() throws Exception {  
  53.         System.out.println("call()方法被自动调用,干活！！！             " + Thread.currentThread().getName());  
  54.         if (new Random().nextBoolean())  
  55.             throw new TaskException("Meet error in task." + Thread.currentThread().getName());  
  56.         // 一个模拟耗时的操作  
  57.         for (int i = 999999999; i > 0; i--)  
  58.             ;  
  59.         return "call()方法被自动调用，任务的结果是：" + id + "    " + Thread.currentThread().getName();  
  60.     }  
  61. }  
  62.   
  63. class TaskException extends Exception {  
  64.     public TaskException(String message) {  
  65.         super(message);  
  66.     }  
  67. }  

执行的结果类似于：

 

[java] view plaincopy
  1. call()方法被自动调用,干活！！！             pool-1-thread-1  
  2. call()方法被自动调用,干活！！！             pool-1-thread-2  
  3. call()方法被自动调用,干活！！！             pool-1-thread-3  
  4. call()方法被自动调用,干活！！！             pool-1-thread-5  
  5. call()方法被自动调用,干活！！！             pool-1-thread-7  
  6. call()方法被自动调用,干活！！！             pool-1-thread-4  
  7. call()方法被自动调用,干活！！！             pool-1-thread-6  
  8. call()方法被自动调用,干活！！！             pool-1-thread-7  
  9. call()方法被自动调用,干活！！！             pool-1-thread-5  
  10. call()方法被自动调用,干活！！！             pool-1-thread-8  
  11. call()方法被自动调用，任务的结果是：0    pool-1-thread-1  
  12. call()方法被自动调用，任务的结果是：1    pool-1-thread-2  
  13. java.util.concurrent.ExecutionException: com.cicc.pts.TaskException: Meet error in task.pool-1-thread-3  
  14.     at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:222)  
  15.     at java.util.concurrent.FutureTask.get(FutureTask.java:83)  
  16.     at com.cicc.pts.ExecutorServiceTest.main(ExecutorServiceTest.java:29)  
  17. Caused by: com.cicc.pts.TaskException: Meet error in task.pool-1-thread-3  
  18.     at com.cicc.pts.TaskWithResult.call(ExecutorServiceTest.java:57)  
  19.     at com.cicc.pts.TaskWithResult.call(ExecutorServiceTest.java:1)  
  20.     at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)  
  21.     at java.util.concurrent.FutureTask.run(FutureTask.java:138)  
  22.     at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)  
  23.     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)  
  24.     at java.lang.Thread.run(Thread.java:619)  
可以看见一旦某个task出错，其它的task就停止执行。
分享到：
| 通过@Value注解读取.properties配置内容
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    ExecutorService的execute和submit方法

    总结起来，`ExecutorService`的`execute()`和`submit()`方法是Java多线程编程中不可或缺的工具，它们帮助我们有效地管理和控制线程的执行，提高了程序的并发性能和稳定性。合理选择和使用这两个方法，可以更好地适应...

    ExecutorService线程池

    2. **提交任务**：使用`execute(Runnable task)`方法提交Runnable任务，或者使用`submit(Callable&lt;T&gt; task)`提交Callable任务并获取Future结果。 3. **关闭线程池**：任务执行完毕后，应调用`shutdown()`或`shutdown...

    2_ExecutorService源码阅读1

    ExecutorService 是 Java 中用于管理和控制线程执行的核心接口，它是 java.util.concurrent 包的一部分。ExecutorService 扩展了 Executor 接口，提供了更丰富的功能，如任务的提交、关闭服务、检查服务状态等。这个...

    Java使用ExecutorService来停止线程服务

    这两个方法的区别在于它们的安全性和响应性。shutdown() 方法会正常关闭线程池，等待所有任务执行完毕后关闭，而 shutdownNow() 方法会强行关闭线程池，取消所有正在执行的任务。 使用 shutdown() 方法来停止线程...

    理解java多线程中ExecutorService使用

    在Java多线程编程中，`ExecutorService`是核心组件之一，它位于`java.util.concurrent`包下，为线程的管理和执行提供了便利。`ExecutorService`不仅简化了线程的创建和管理，而且通过其丰富的API使得多线程编程更加...

    简单谈谈ThreadPoolExecutor线程池之submit方法

    在 Executor 接口中，只定义了 execute 方法，而 submit 方法则是在 ExecutorService 接口中定义的。 ```java public interface ExecutorService extends Executor { ... &lt;T&gt; Future&lt;T&gt; submit(Callable&lt;T&gt; task)...

    线程池核心组件源码剖析.docx

    该组件中，Executor 和 ExecutorService 接口 定义了线程池最核心的几个方法，提交任务 submit ()、关闭线程池 shutdown()。抽象类 AbstractExecutorService 主要对公共行为 submit()系列方法进行了实现，这些 ...

    java多线程实现大批量数据导入源码

    可以使用`ExecutorService`的`submit()`或`execute()`方法来执行任务，每个任务通常是一个实现了`Runnable`或`Callable`接口的对象。 在数据导入过程中，每个线程负责处理一部分数据，可能涉及到数据库连接的建立、...

    Executor框架使用详解

    基于`Executor`，`ExecutorService`接口提供了更丰富的功能，如关闭线程池的`shutdown()`和`shutdownNow()`方法，以及管理和控制任务执行的方法，如`submit()`、`invokeAll()`和`invokeAny()`。`ExecutorService`...

    java基础知识之hadoop源码阅读必备(一).docx

    然后，通过`ExecutorService`的`submit()`方法提交这个任务，它会在新的线程中运行。这种方式不会返回结果，适用于无需等待任务完成的情况。 示例代码： ```java ExecutorService executor = Executors....

    高并发编程,高并发编程,高并发编程

    * AbstractExecutorService是Java中的抽象线程池类，提供了execute()和submit()方法的默认实现。 七、高并发编程的其他知识点 * volatile关键字可以确保变量的可见性和原子性。 * synchronized关键字可以确保方法...

    Java线程创建的四种方式

    以上四种方式中，继承Thread或实现Runnable适合简单的线程创建，而Executor框架和Callable接口适用于更复杂的并发控制和结果处理。在实际开发中，我们通常会根据需求选择最适合的线程创建方法。对于大型项目，推荐...

    Android线程池ExcutorService

    通过`ExecutorService`的`execute(Runnable task)`方法提交任务，或者使用`submit(Callable&lt;T&gt; task)`提交返回结果的任务。`Runnable`接口用于无返回值的任务，而`Callable`接口则支持带返回值的任务。 5. **关闭...

    21-多线程和线程同步1

    * ExecutorService 接口：提供了 execute() 方法、shutdown() 方法和 submit() 方法，用于执行 Runnable 任务和管理线程池。 * ThreadPoolExecutor 类：是一个线程池执行器，提供了一个固定大小的线程池。 Callable...

    java定时器+多线程(池)+java队列Demo

    队列可以用于任务调度，例如，`ExecutorService`的`submit`方法将任务放入内部队列，由线程池按顺序处理。此外，`BlockingQueue`接口提供了一种线程安全的队列，适用于多线程环境中的生产者-消费者模型。 在...

    线程池的概念

    2. 调用`ExecutorService`的`submit`或`execute`方法提交任务。 3. 当不再有任务需要执行时，调用`shutdown`方法优雅地关闭线程池，等待所有任务执行完毕；若需立即停止，可使用`shutdownNow`。 线程池的优化主要...

    线程池&lambda表达式习题答案1

    此外，线程池可以通过`ExecutorService`的`submit()`或`execute()`方法提交任务，例如： ```java ExecutorService executor = Executors.newFixedThreadPool(5); // 创建固定大小的线程池 executor.execute(() -&gt; { ...

    Java线程池完整代码，已经用于实际的项目中，性能稳定.zip

    线程池通常使用`execute()`方法来提交`Runnable`任务，或者使用`submit()`方法来提交`Callable`任务，后者会返回一个`Future`对象，可以用来获取任务执行的结果或检查任务状态。 线程池的工作流程大致如下： 1. **...

    java.util.concurrent-多线程框架.docx

    ExecutorService 接口提供了多种方法，包括 execute()、submit()、shutdown() 等，以便开发者更方便地管理线程池。 在上面的代码中，我们可以看到，使用 ExecutorService 接口来创建了一个固定大小的线程池，然后...

    几种方法编写线程代码

    线程是操作系统调度的基本单位，它允许程序同时执行多个任务，极大地提高了程序的并发性和效率。...在实际项目中，结合使用`ExecutorService`和线程池通常是最佳实践，因为它们提供了更好的性能和资源管理。

Magicbox
Global site tag (gtag.js) - Google Analytics