线程池方式开启线程--submit()和execute()的区别

已于 2022-07-24 21:47:06 修改
阅读量2.1k 收藏 11
点赞数 2
文章标签： java jvm 开发语言 maven spring
于 2022-07-24 21:45:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57640408/article/details/125962457
版权
本文详细介绍了如何使用Java线程池执行有返回值和无返回值的任务，通过示例代码展示了submit()和execute()的区别。submit()方法能处理Callable和Runnable任务，异常会被捕获，可以通过Future获取结果；execute()仅接受Runnable任务，异常会直接抛出。在实际应用中，根据需求选择合适的方法。
摘要由CSDN通过智能技术生成

目录

1. 线程池方式开启线程

1.1 创建线程池，并开启有返回值的线程的代码

1.2 创建线程池，并开启无返回值的线程

2. submit()和execute()提交任务的区别

2.1 submit代码展示

 2.1.2 submit提交任务，异常被吃，通过Future的get方法将任务执行时的异常重新抛出

 2.2 execute代码展示

 2.2.1 execute提交的线程可以通过FutureTask获取线程结果

没有引用线程池的时候，需要我们通过继承Thread类和实现Runnable、Callable接口，最终调用start()方法启动线程。

想要理解线程和线程池介绍，可以学习下这篇博客：多线程--线程和线程池的用法_傻鱼爱编程的博客-CSDN博客

现在我们可以通过线程池的execute()和submit()方法来提交线程任务。

1. 线程池方式开启线程

提交的任务可以选择是否需要返回值：

1.1 创建线程池，并开启有返回值的线程的代码

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        int inter = 6;
        System.out.println("电脑核心线程数 = " + Runtime.getRuntime().availableProcessors());
        // 创建线程池（自定义参数）
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                6,
                10,
                10L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(10),
                new CustomizableThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());

        // 定义线程数组（也可以用线程集合）
        FutureTask[] futureTask = new FutureTask[inter];
        // 开启6个线程
        for (int i = 0; i < inter; i++) {
            futureTask[i] = new FutureTask<>(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    // 模拟程序执行时间1S
                    Thread.sleep(1000);
                    System.out.println("线程数量activeCount = " + poolExecutor.getActiveCount());
                    System.out.println("排队数量size = " + poolExecutor.getQueue().size());
                    return "Callable在线程池中执行了。。" + Thread.currentThread().getName();
                }
            });
            // 线程池开启线程
            poolExecutor.submit(futureTask[i]);
        }
        // 获取线程的执行结果
        for (FutureTask task : futureTask) {
            System.out.println("task返回结果 = " + task.get());
        }
        // 关闭线程池（现实项目中不关线程池）
        poolExecutor.shutdown();
    }

1.2 创建线程池，并开启无返回值的线程

public static void main(String[] args) {
        int inter = 6;
        System.out.println("电脑核心线程数 = " + Runtime.getRuntime().availableProcessors());
        // 创建线程池（自定义参数）
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                5,
                10,
                10L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(10),
                new CustomizableThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());

        // 定义线程数组（也可以用线程集合）
        Runnable[] runnables = new Runnable[inter];
        // 开启6个线程
        for (int i = 0; i < inter; i++) {
            runnables[i] = new Runnable() {
                @Override
                public void run() {
                    // 模拟程序执行
                    System.out.println("添加需要运行的程序===");
                    System.out.println("线程池线程总数量 = " + poolExecutor.getPoolSize());
                    System.out.println("线程数量activeCount = " + poolExecutor.getActiveCount());
                    System.out.println("排队数量size = " + poolExecutor.getQueue().size());
                }
            };
            // 线程池开启线程
            poolExecutor.submit(runnables[i]);
        }
        // 关闭线程池（现实项目中不关线程池）
        poolExecutor.shutdown();
    }

2. submit()和execute()提交任务的区别

submit()execute()
提交任务的类型既能提交Runnable类型任务也能提交Callable类型任务只能提交Runnable类型的任务（）
异常的处理方式会吃掉异常。可通过Future的get方法将任务执行时的异常重新抛出

会直接抛出任务执行时的异常

是否有返回值

有返回值，需要返回值的时候可以使用submit

execute()没有返回值，可通过Future的get方法获取返回值

2.1 submit代码展示

源码展示（可以提交Callable类型和Runable类型）：

2.1.1 submit提交任务，异常被吃的情况

    public static void main(String[] args) {
        int inter = 3;
        // 创建线程池（自定义参数）
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 定义线程数组（也可以用线程集合）
        Callable[] callables = new Callable[inter];
        // 开启6个线程
        for (int i = 0; i < inter; i++) {
            callables[i] = new Callable<String>(){
                @Override
                public String call() throws Exception {
                    System.out.println("添加需要运行的程序===");
                    Thread.sleep(10*1000);
                    // 手动添加一个异常
                    int aa =1/0;
                    return "程序运行成功";
                }
            };
            // 线程池开启线程
            executorService.submit(callables[i]);
        }
        // 关闭线程池（现实项目中不关线程池）
        executorService.shutdown();
    }

控制台打印结果：无异常抛出

 2.1.2 submit提交任务，异常被吃，通过Future的get方法将任务执行时的异常重新抛出

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        int inter = 3;
        // 创建线程池（自定义参数）
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 定义线程数组（也可以用线程集合）
        Callable[] callables = new Callable[inter];
        ArrayList<Future> futureTasks = new ArrayList<>();
        // 开启6个线程
        for (int i = 0; i < inter; i++) {
            callables[i] = new Callable<String>(){
                @Override
                public String call() throws Exception {
                    System.out.println("添加需要运行的程序===");
                    Thread.sleep(10*1000);
                    // 手动添加一个异常
                    int aa =1/0;
                    return "程序运行成功";
                }
            };
            // 线程池开启线程
            Future submit = executorService.submit(callables[i]);
            futureTasks.add(submit);
        }
        // 获取线程结果
        for (Future futureTask : futureTasks) {
            System.out.println("返回结果 = " + futureTask.get());
        }
        // 关闭线程池（现实项目中不关线程池）
        executorService.shutdown();
    }

控制台打印：异常被抛出

 2.2 execute代码展示

源码展示（只能提交Runable类型）：

 2.2.1 execute提交的线程可以通过FutureTask获取线程结果

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        int inter = 3;
        // 创建线程池（自定义参数）
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 定义线程数组（也可以用线程集合）
        FutureTask[] integerFuture = new FutureTask[inter];
        // 开启6个线程
        for (int i = 0; i < inter; i++) {
            integerFuture[i] = new FutureTask<>(new Callable<Object>() {
                @Override
                public Object call() throws Exception {
                    System.out.println("添加需要运行的程序===");
                    Thread.sleep(10*1000);
                    return "程序返回的结果";
                }
            });
            // 线程池开启线程
            executorService.execute(integerFuture[i]);
        }
        // 通过FutureTask获取结果
        for (FutureTask futureTask : integerFuture) {
            System.out.println("获取的线程结果：" + futureTask.get());
        }
        // 关闭线程池（现实项目中不关线程池）
        executorService.shutdown();
    }

总结：通过submit()和execute()源码可以看出submit封装了execute，如果没有特殊情况应该优先选择execute。因为execute效率会更高，异常也不会被吃掉。

傻鱼爱编程
关注
线程池的submit和execute的区别.md
09-26
### 线程池的submit和execute方法的区别详解 #### 一、引言 线程池作为Java并发编程中的一项关键技术，在实现高效并发任务管理方面发挥着重要作用。而在实际开发中，开发者经常会遇到两种用于向线程池提交任务的...
JAVA线程池submit详解 ，execute和submit提交任务的区别
胖虎儿的博客
06-21 1万+
JAVA线程池submit详解 ，execute和submit提交任务的区别
Java线程池系列之execute和submit区别
热门推荐
forever的专栏
01-08 1万+
这是几年前的一道面试题了，网上的答案一般都是 1. execute只能提交Runnable类型的任务，没有返回值，而submit既能提交Runnable类型任务也能提交Callable类型任务，返回Future类型。 2. execute方法提交的任务异常是直接抛出的，而submit方法是是捕获了异常的，当调用FutureTask的get方法时，才会抛出异常。 我们可能看过n多次但又忘了n多加1次，那么我们到底应该如何才能彻底理解和记住这两者的区别呢，这就要从ThreadPoolExecutor的根
java多线程之线程池
最新发布
bobplease的博客
08-06 1049
总结了线程池的基础知识，以及面试常见八股问题，并结合了场景简述了不同的线程池的适用场景。
线程池-两种提交任务的方法execute()与submit()详解
张念磊的博客
12-10 1万+
引言 线程池中有两个提交任务的方法 向线程池提交任务的两种方式大致如下： 方式一：调用execute()方法 // todo 源码 方式二：调用submit()方法 // todo 源码 一、区别 以上的submit()和execute()两类方法的区别在哪里呢？大致有以下三点： 1.二者所接收的参数不一样 Execute()方法只能接收Runnable类型的参数，而submit()方法可以接收Callable、Runnable两种类型的参数。Callable类型的任务是可以返回执行结果的，而Runnabl
Java线程池submit阻塞获取结果实现原理
BASK2311的博客
10-23 2239
Java线程池中提交任务运行，通常使用execute()方法就足够了。那如果想要实现在主线程中阻塞获取线程池任务运行的结果，该怎么办呢？答案是用submit()方法提交任务。这也是面试中经常被问到的一个知识点，execute()和submit()提交任务的的区别是什么？底层是如何实现的？submit()方法中调用方法获取对象。// 调用FutureTask的构造方法返回RunnableFuture对象}复制代码FutureTaskFutureTask是一个异步计算任务，包装了我们外部提交的任务。
启动线程的四种方式
qq_36614280的博客
12-18 1343
test
java线程池源码-java-source:Java源码学习多线程、线程池、集合
05-25
- **Worker**：每个线程池线程都是一个Worker对象，它继承自`AbstractExecutorService`，包含了线程和一个内部的`Future`对象，用于表示线程执行的任务结果。 - **WorkQueue**：存储待执行任务的队列，根据不同的...
Java线程池学习资料-全
08-11
`execute()`和`submit()`方法是线程池提交任务的两种方式。`execute()`接受`Runnable`对象，而`submit()`可以接受`Callable`对象，它会将`Callable`封装成`FutureTask`后再调用`execute()`。`SynchronousQueue`是一...
简单谈谈ThreadPoolExecutor线程池之submit方法
08-30
在 Java 中，ThreadPoolExecutor 是一个非常重要的线程池实现类，它提供了多种方式来执行任务，其中 submit 方法是其中一个重要的方法，本文将详细解释 ThreadPoolExecutor 的 submit 方法。 首先，我们需要了解 ...
Android开发经验谈：并发编程（线程与线程池）（推荐）
08-26
ThreadPoolExecutor类提供了许多方法来控制线程池的行为，如execute()、submit()、shutdown()等方法。我们可以使用这些方法来提交任务、关闭线程池等。 此外，我们还需要了解线程池的线程工厂和任务队列。线程工厂...
java线程池_submit()
weixin_44613100的博客
06-10 5985
submit()方法 有三个重载方法： submit（Callable<T> task）//参数为Callable接口的实现类的实例 submit(Runnable task, T result)//第二个参数为默认值 submit(Runnable task) 线程池测试类 package com.thread.pool; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executor
线程池submit和execute方法原理
kai3123919064的博客
05-19 8524
线程池的作用 : 1. 避免大量的线程强占资源 2. 避免大量的线程创建和销毁带来的开销 线程池的原理 : 创建线程池的时候,可以使用executors的静态方法,也可以使用new ThreadPoolExecutor的方式手动创建线程池,通过在线程池中指定参数达到创建不同类型的线程池的效果 其中,executors底层其实也是调用的new ThreadPoolExecutor()的方式创...
java_多线程——线程池、submit和execute区别
qq_59727955的博客
08-14 3297
线程池、submit和execute区别
13.ThreadPoolExecutor线程池之submit方法
weixin_33754913的博客
06-17 652
jdk1.7.0_79  　　在上一篇《ThreadPoolExecutor线程池原理及其execute方法》中提到了线程池ThreadPoolExecutor的原理以及它的execute方法。本文解析ThreadPoolExecutor#submit。 　　对于一个任务的执行有时我们不需要它返回结果，但是有我们需要它的返回执行结果。对于线程来讲，如果不需要它返回结果则实现Runnable，而...
Java线程池中的execute和submit
SweetoDream
02-01 4798
execute和submit都是线程池中执行任务的方法。execute是Executor接口中的方法submit是接口中的方法。通过源码可以看出execute方法无返回值，参数为Runnable对象。submit方法有三个重载方法，都有Future类型的返回值，参数可以是Runnable对象，Callable对象，Runnable对象和一个其他类型的对象。执行结果如下：结果如下：可见使用submit方法时只有在使用Future的get方法时才会抛出异常，并且get方法也会抛出异常。
深度解析多线程的创建方式和正确启动多线程
Qynwang的博客
05-25 908
准确的讲，创建线程只有一种方式那就是构造Thread类，而实现线程的执行单元有两种方式：一是实现Runnable接口的run方法，并把Runnable实例传给Thread类，二是重写Thread的run方法（继承Thread类）其它创建线程的方式也有很多，但都是在代码的写法上的千变万化，本质上还是都基于 Thread 类和 Runnable 类的重写run()方法。方法一：最终调用Runnable实例的run()方法（target.run()）;方法二：直接将Thread类的里整个 run() 方法重写。
Java线程池中submit() 和 execute()方法有什么区别？
NZC2237的博客
01-10 774
submit()` 方法可以接受 `Callable` 或 `Runnable` 类型的任务，并返回一个 `Future` 对象，你可以通过 `Future` 对象获取任务的执行结果或者取消任务执行。`submit()` 方法是 `ExecutorService` 接口中定义的方法，在 `Executor` 的基础上增加了任务提交后可以获取任务执行结果的能力。`execute()` 方法是 `Executor` 接口中定义的方法，较为简单，用于执行 `Runnable` 任务。
线程池是如何启动线程的
清风自来
11-17 3416
啃完小龙虾掐指一算，周末又要结束了，赶紧来记录并分享点东西… … … 日常工作中多多少少都会需要用多线程去处理一些事情，下面就来记录并分享下线程池启动线程相关的知识： 一、线程池的好处 合理利用线程池会带来以下好处： 无限制的创建和销毁线程不仅会消耗系统资源还会降低系统的稳定性，线程池减少了线程的创建和销毁操作，从而可以提高一些性能。需要线程时，线程可立即执行，无需重新创建。 二、启动策略 1）当...
线程池submit与execute的区别详解
"这篇Markdown文档讨论了Java线程池中`submit()`和`execute()`方法的区别，主要聚焦于它们在处理任务提交、结果获取以及异常处理上的差异。" 线程池是Java并发编程中非常重要的工具，它允许我们管理线程资源，避免...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值