ThreadPoolExecutor的execute()和submit()方法

最新推荐文章于 2022-07-29 15:29:31 发布
最新推荐文章于 2022-07-29 15:29:31 发布
阅读量1.8w 收藏 33
点赞数 5
分类专栏： 线程相关 文章标签： ThreadPoolExecutor submit() execute()
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37822338/article/details/100010495
版权

我希望使用多线程执行一个运算，并且线程执行完毕后我要获取执行结果。其实使用线程池ThreadPoolExecutor的execute()和submit()方法都可以。

使用execute()的话，事先定义一个存放返回结果的集合，开辟线程时，将集合的元素作为参数代入自定义的Runnable接口的实现类中，多线程执行完毕后遍历集合即可获得运算结果。

使用submit()的话，可以在submit()中执行一个Callable接口的实现类，submit()方法可以返回一个Future<> future，然后使用future.get()方法获得返回结果，由于future.get()会使调用线程池的线程阻塞，等待返回结果，所以可以先将Future<> future放入一个集合，等多线程执行完毕后再遍历集合获得运算结果。

使用execute()方法：

定义一个结果类：

public class RunResult {
    // 输入参数
    private Integer param;
    // 是否运算成功
    private Boolean success;
    // 运算结果
    private Integer result;
    public Integer getParam() {
        return param;
    }
    public void setParam(Integer param) {
        this.param = param;
    }
    public Boolean getSuccess() {
        return success;
    }
    public void setSuccess(Boolean success) {
        this.success = success;
    }
    public Integer getResult() {
        return result;
    }
    public void setResult(Integer result) {
        this.result = result;
    }
}

定义一个Runnable接口的实现类：

public class MyRunnable implements Runnable {
    // 运算结果类
    private RunResult result;
    // 线程同步器
    private CountDownLatch main;
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name + " 线程开始执行" + "-" + result.getParam());
        for (int i = 0; i < 1; i++) {
            for (int j = 1; j <= 200000000; j++) {
                if (j == 200000000 && null != result.getParam()) {
                    result.setResult(result.getParam()*10);
                    result.setSuccess(true);
                    System.out.println(name + " 线程正在进行计算" + "-" + result.getParam());
                } else {
                    result.setSuccess(false);
                }
            }
        }
        System.out.println(name + " 线程执行完毕" + "-" + result.getParam());
        main.countDown();
    }
    public MyRunnable(RunResult result, CountDownLatch main) {
        super();
        this.result = result;
        this.main = main;
    }
    public MyRunnable() {
        super();
    }
}

main方法：

    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(6, 10, 10L, TimeUnit.SECONDS, 
                new LinkedBlockingQueue<Runnable>(20),
                Executors.defaultThreadFactory(), 
                new ThreadPoolExecutor.CallerRunsPolicy());
        // 存放结果类的集合
        List<RunResult> list = new ArrayList<RunResult>(12);
        // 线程同步器
        CountDownLatch main = new CountDownLatch(12);
        for (int i = 1; i <= 12; i++) {
            RunResult result = new RunResult();
            result.setParam(i);
            list.add(result);
            MyRunnable runnable = new MyRunnable(result,main);
            threadPool.execute(runnable);
        }
        try {
            main.await();
            System.out.println(JSON.toJSON(list));
            // 线程池不用了，关闭线程池
            threadPool.shutdown();
            //threadPool.shutdownNow();
        } catch (InterruptedException e) {
            
        }
    }

执行结果：

pool-1-thread-1 线程开始执行-1
pool-1-thread-5 线程开始执行-5
pool-1-thread-3 线程开始执行-3
pool-1-thread-2 线程开始执行-2
pool-1-thread-4 线程开始执行-4
pool-1-thread-6 线程开始执行-6
pool-1-thread-1 线程正在进行计算-1
pool-1-thread-1 线程执行完毕-1
pool-1-thread-1 线程开始执行-7
pool-1-thread-6 线程正在进行计算-6
pool-1-thread-6 线程执行完毕-6
pool-1-thread-6 线程开始执行-8
pool-1-thread-5 线程正在进行计算-5
pool-1-thread-5 线程执行完毕-5
pool-1-thread-5 线程开始执行-9
pool-1-thread-3 线程正在进行计算-3
pool-1-thread-3 线程执行完毕-3
pool-1-thread-3 线程开始执行-10
pool-1-thread-4 线程正在进行计算-4
pool-1-thread-4 线程执行完毕-4
pool-1-thread-4 线程开始执行-11
pool-1-thread-2 线程正在进行计算-2
pool-1-thread-2 线程执行完毕-2
pool-1-thread-2 线程开始执行-12
pool-1-thread-5 线程正在进行计算-9
pool-1-thread-5 线程执行完毕-9
pool-1-thread-4 线程正在进行计算-11
pool-1-thread-4 线程执行完毕-11
pool-1-thread-2 线程正在进行计算-12
pool-1-thread-2 线程执行完毕-12
pool-1-thread-6 线程正在进行计算-8
pool-1-thread-3 线程正在进行计算-10
pool-1-thread-3 线程执行完毕-10
pool-1-thread-1 线程正在进行计算-7
pool-1-thread-6 线程执行完毕-8
pool-1-thread-1 线程执行完毕-7
[{"result":10,"param":1,"success":true},{"result":20,"param":2,"success":true},{"result":30,"param":3,"success":true},{"result":40,"param":4,"success":true},{"result":50,"param":5,"success":true},{"result":60,"param":6,"success":true},{"result":70,"param":7,"success":true},{"result":80,"param":8,"success":true},{"result":90,"param":9,"success":true},{"result":100,"param":10,"success":true},{"result":110,"param":11,"success":true},{"result":120,"param":12,"success":true}]

使用submit()方法：

返回结果类同上

定义一个Callable接口的实现类：

public class MyCallable implements Callable<RunResult> {
    // 运算结果类
    private RunResult result;
    // 线程同步器
    private CountDownLatch main;
    @Override
    public RunResult call() throws Exception {
        String name = Thread.currentThread().getName();
        System.out.println(name + " 线程开始执行" + "-" + result.getParam());
        for (int i = 0; i < 1; i++) {
            for (int j = 1; j <= 200000000; j++) {
                if (j == 200000000 && null != result.getParam()) {
                    result.setResult(result.getParam()*10);
                    result.setSuccess(true);
                    System.out.println(name + " 线程正在进行计算" + "-" + result.getParam());
                } else {
                    result.setSuccess(false);
                }
            }
        }
        System.out.println(name + " 线程执行完毕" + "-" + result.getParam());
        main.countDown();
        return result;
    }
    public MyCallable(RunResult result, CountDownLatch main) {
        super();
        this.result = result;
        this.main = main;
    }
    public MyCallable() {
        super();
    }
}

main方法：

    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(6, 10, 10L, TimeUnit.SECONDS, 
                new LinkedBlockingQueue<Runnable>(20),
                Executors.defaultThreadFactory(), 
                new ThreadPoolExecutor.CallerRunsPolicy());
        // 存放Future<>的集合
        List<Future<RunResult>> list = new ArrayList<Future<RunResult>>(12);
        // 线程同步器
        CountDownLatch main = new CountDownLatch(12);
        for (int i = 1; i <= 12; i++) {
            RunResult result = new RunResult();
            result.setParam(i);
            MyCallable callable = new MyCallable(result,main);
            Future<RunResult> runResultFuture = threadPool.submit(callable);
            list.add(runResultFuture);
        }
        try {
            main.await();
            for (int i = 0; i < list.size(); i++) {
                RunResult runResult = list.get(i).get();
                System.out.println(JSON.toJSON(runResult));
            }
            // 线程池不用了，关闭线程池
            threadPool.shutdown();
            //threadPool.shutdownNow();
        } catch (InterruptedException e) {
            
        } catch (ExecutionException e) {
            
        }
    }

执行结果：

pool-1-thread-3 线程开始执行-3
pool-1-thread-4 线程开始执行-4
pool-1-thread-2 线程开始执行-2
pool-1-thread-1 线程开始执行-1
pool-1-thread-5 线程开始执行-5
pool-1-thread-6 线程开始执行-6
pool-1-thread-1 线程正在进行计算-1
pool-1-thread-3 线程正在进行计算-3
pool-1-thread-5 线程正在进行计算-5
pool-1-thread-5 线程执行完毕-5
pool-1-thread-2 线程正在进行计算-2
pool-1-thread-2 线程执行完毕-2
pool-1-thread-6 线程正在进行计算-6
pool-1-thread-6 线程执行完毕-6
pool-1-thread-4 线程正在进行计算-4
pool-1-thread-4 线程执行完毕-4
pool-1-thread-6 线程开始执行-9
pool-1-thread-5 线程开始执行-7
pool-1-thread-2 线程开始执行-8
pool-1-thread-3 线程执行完毕-3
pool-1-thread-3 线程开始执行-11
pool-1-thread-1 线程执行完毕-1
pool-1-thread-1 线程开始执行-12
pool-1-thread-4 线程开始执行-10
pool-1-thread-6 线程正在进行计算-9
pool-1-thread-5 线程正在进行计算-7
pool-1-thread-5 线程执行完毕-7
pool-1-thread-1 线程正在进行计算-12
pool-1-thread-1 线程执行完毕-12
pool-1-thread-4 线程正在进行计算-10
pool-1-thread-2 线程正在进行计算-8
pool-1-thread-3 线程正在进行计算-11
pool-1-thread-6 线程执行完毕-9
pool-1-thread-3 线程执行完毕-11
pool-1-thread-2 线程执行完毕-8
pool-1-thread-4 线程执行完毕-10
{"result":10,"param":1,"success":true}
{"result":20,"param":2,"success":true}
{"result":30,"param":3,"success":true}
{"result":40,"param":4,"success":true}
{"result":50,"param":5,"success":true}
{"result":60,"param":6,"success":true}
{"result":70,"param":7,"success":true}
{"result":80,"param":8,"success":true}
{"result":90,"param":9,"success":true}
{"result":100,"param":10,"success":true}
{"result":110,"param":11,"success":true}
{"result":120,"param":12,"success":true}

参考博客：ThreadPoolExecutor中的submit()方法详细讲解

闪耀之城
关注
  • 5
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程池ThreadPoolExecutor中submit方法和execute方法的区别和关系
任枫的博客
05-17 3906
ThreadPoolExecutor是线程池，其继承AbstractExecutorService，如下代码： package java.util.concurrent; import java.util.ArrayList; import java.util.ConcurrentModificationException; import java.util.HashSet; import ...
Java线程池execute和submit的区别
最新发布
程序员小潘
06-04 611
ThreadPoolExecutor提供了两种方法来执行异步任务，分别是execute和submit，也是日常开发中经常使用的方法，那么它俩有什么区别呢？
ThreadPoolExecutor execute和submit
robinson_911的专栏
07-25 2106
多线程里面还有一个比较有意思的地方就是往线程池中提交线程的时候其实有两种方法：一种是execute另外一种是submit 一. execute提交的方式 execute提交的方式只能提交一个Runnable的对象，且该方法的返回值是void，也即是提交后如果线程运行后，和主线程就脱离了关系了，当然可以设置一些变量来获取到线程的运行结果。并且当线程的执行过程中抛出了异常通常来说主线程也无法获取到...
ThreadPoolExecutor线程池execute和submit的区别
wenpan的博客
08-30 1万+
结论 基本没有区别，在submit方法中仍然是调用的execute方法进行任务的执行或进入等待队列或拒绝。 submit方法比execute方法多的只是将提交的任务（不管是runnable类型还是callable类型）包装成RunnableFuture然后传递给execute方法执行。 源码对比 ①、execute源码 public void execute(Runnable command) { if (command == null) throw new NullPoin.
线程池ThreadPoolExecutor中execute和submit方法对比
weixin_38569499的博客
06-16 2457
方法定义： // ExecutorService接口中定义的方法： Future<?> submit(Runnable task); <T> Future<T> submit(Runnable task, T result); <T> Future<T> submit(Callable<T> task); // Threa...
线程池（三）----ThreadPoolTaskExecutor的提交方法execute和submit
这个人很懒，什么都没有留下。
07-29 1万+
线程池（三）----ThreadPoolTaskExecutor的提交方法execute和submit
ThreadPoolExecutor线程池之submit方法
huangchunxia_1的博客
08-05 1378
转载自：https://www.cnblogs.com/yulinfeng/p/7039979.html jdk1.7.0_79  　　在上一篇《ThreadPoolExecutor线程池原理及其execute方法》中提到了线程池ThreadPoolExecutor的原理以及它的execute方法。本文解析ThreadPoolExecutor#submit。 　　对于一个任务的执行有时我们不...
execute和submit的区别
热门推荐
sxp知识共享
11-18 2万+
1、execute和submit的区别 提交任务的类型： execute和submit都属于线程池的方法，execute只能提交Runnable类型的任务 submit既能提交Runnable类型任务也能提交Callable类型任务。 异常： execute会直接抛出任务执行时的异常，可以用try、catch来捕获，和普通线程的处理方式完全一致 submit会吃掉异常，可通过Future的get方法将任务执行时的异常重新抛出。 返回值： execute()没有返回值 submi
线程池ThreadPoolTaskExecutor的提交方法execute和submit
五月,难忘的悲伤 的博客
07-24 1万+
无返回值的任务使用public void execute(Runnable command) 方法提交； 有返回值的任务使用public <T> Future<T> submit(Callable) 方法提交。 下面具体来看下两者的应用以及区别。 一、与主线程执行顺序的区别： 1、 （1）public void execute(Runnable command) 方法提交,子线程可能在主线程结束之后结束； 举例： @RequestMapping("/execute") pu
简单谈谈ThreadPoolExecutor线程池之submit方法
08-30
"ThreadPoolExecutor线程池之submit方法详解" 在 Java 中，ThreadPoolExecutor 是一个非常重要的线程池实现类，它提供了多种方式来执行任务，其中 submit 方法是其中一个重要的方法，本文将详细解释 ...
线程池ThreadPoolExecutor
12-21
`ExecutorService`是线程池的主要接口，提供了执行任务的方法，如`execute()`用于执行无返回值的`Runnable`任务，以及`submit()`用于执行有返回值的`Callable`任务。`shutdown()`方法用于关闭线程池，停止接收新任务...
java ThreadPoolExecutor 并发调用实例详解
08-30
ThreadPoolExecutor 还提供了多种方式来提交任务，包括 execute()、submit() 和 invokeAll() 等。 在给定的代码中，我们可以看到一个使用 ThreadPoolExecutor 并发调用实例的示例。在这个示例中，我们首先创建了一...
redis lits queue 和 ThreadPoolExecutor 结合
05-03
- **任务分发**：使用Java的Jedis或Redisson等客户端库与Redis通信，获取任务后，创建`Runnable`或`Callable`对象，然后调用ThreadPoolExecutor的`execute`或`submit`方法提交任务。 - **线程池配置**：根据系统...
几种方法编写线程代码
07-06
在编程中，我们有多种方法来创建和管理线程。以下是对这些方法的详细阐述，适合初学者理解。 1. 继承Thread类： 在Java中，最常见的方式是继承`java.lang.Thread`类并重写它的`run()`方法。当你调用`start()`方法时...
SimpleDateFormat线程不安全的原因以及解决方案
m0_37822338的博客
08-21 509
阿里巴巴java开发手册强制要求： 5. 【强制】SimpleDateFormat 是线程不安全的类，一般不要定义为 static 变量，如果定义为 static，必须加锁，或者使用 DateUtils 工具类。（org.apache.commons.lang3.time.DateUtils） 因为SimpleDateFormat 继承DateFormat，DateFormat中定义了属性ca...
使用 ThreadLocal 或 InheritableThreadLocal 对线程内部对象做缓存，实现线程内对象的复用
m0_37822338的博客
08-21 501
在java.lang.Thread类中有两个属性 ThreadLocal.ThreadLocalMap threadLocals ThreadLocal.ThreadLocalMap inheritableThreadLocals 这里的ThreadLocalMap 类相当于一个Map，key 是 ThreadLocal 对象，value 就是存储的值。 threadLocals 里边的值...
线程中sleep()、wait()、join()、yield()方法的使用
m0_37822338的博客
08-22 473
/* sleep()方法使当前线程放弃CPU使用权，但是不释放已抢占对象的锁，当前线程阻塞。其他线程可以抢占cpu使用权，但无法抢占对象的锁。sleep 方法允许较低优先级的线程获得运行机会 sleep()方法是Thread类的静态方法 Thread.sleep(2000);线程休眠2秒 thread.interrupt();可以终止线程的阻塞，并抛出InterruptedException异常，...
threadpoolexecutor中的execute方法和submit方法的区别
05-20
`ThreadPoolExecutor` 是 Java 中用于管理线程池的类。它提供了两种提交任务的方法：`execute` 和 `submit`。 `execute` 方法用于提交一个 `Runnable` 任务，返回值为 `void`，即不会返回任何结果或抛出异常。如果任务执行过程中发生异常，将会在控制台输出错误信息。 `submit` 方法用于提交一个 `Callable` 或 `Runnable` 任务，返回一个 `Future` 对象，用于获取任务执行结果或异常。如果任务执行过程中发生异常，将会被封装成 `ExecutionException` 并通过 `Future.get()` 方法抛出。 因此，如果你只需要提交一个简单的 `Runnable` 任务，不需要关心任务执行结果或异常，可以使用 `execute` 方法。如果你需要获取任务执行结果或异常，或者提交一个 `Callable` 任务，应该使用 `submit` 方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值