Java Executors创建四种线程池详解及常见错误案例

于 2024-10-24 11:37:20 发布
阅读量950 收藏 6
点赞数 14
分类专栏： 开发工具 个人日记 jvm 文章标签： 1024程序员节 java Executors 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39970883/article/details/143204964
版权

文章目录

引言

在多线程编程中，线程池是一种非常重要的技术，它可以帮助我们更高效地管理和复用线程资源。Java提供了丰富的线程池实现，通过ExecutorService接口及其子类，我们可以轻松地创建和管理线程池。本文将详细介绍Java线程池的几种常见类型，并给出示例代码和常见错误案例。

在这里插入图片描述

Java线程池类型

1. FixedThreadPool

特点：
固定大小的线程池。
创建的线程池中的线程数量固定，超出的线程将在队列中等待。
适用于负载较重且任务数量较多的场景。
示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * FixedThreadPoolExample
 * @author senfel
 * @version 1.0
 * @date 2024/10/24 11:17
 */
public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}

2. CachedThreadPool

特点：
可缓存的线程池。
线程池中的线程数量不固定，可以根据需要动态增加。
适用于执行大量短期异步任务的场景。
示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * CachedThreadPoolExample
 * @author senfel
 * @version 1.0
 * @date 2024/10/24 11:18
 */
public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}

3. SingleThreadExecutor

特点：
单线程的线程池。
只有一个工作线程，任务按顺序执行。
适用于需要保证任务顺序执行的场景。
示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * SingleThreadExecutorExample
 * @author senfel
 * @version 1.0
 * @date 2024/10/24 11:18
 */
public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}

4. ScheduledThreadPool

特点：
定时任务线程池。
支持定时和周期性任务的执行。
适用于需要定期执行任务的场景。
示例代码：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
 * ScheduledThreadPoolExample
 * @author senfel
 * @version 1.0
 * @date 2024/10/24 11:19
 */
public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);

        // 定时任务，延迟1秒后执行
        executor.schedule(() -> {
            System.out.println("Scheduled task is running on thread " + Thread.currentThread().getName());
        }, 1, TimeUnit.SECONDS);

        // 周期性任务，初始延迟1秒后开始，每隔2秒执行一次
        executor.scheduleAtFixedRate(() -> {
            System.out.println("Periodic task is running on thread " + Thread.currentThread().getName());
        }, 1, 2, TimeUnit.SECONDS);

        // 避免程序立即退出
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        executor.shutdown();
    }
}

常见错误案例

1. 忘记关闭线程池

错误代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * ThreadPoolShutdownExample
 * @author senfel
 * @version 1.0
 * @date 2024/10/24 11:21
 */
public class ThreadPoolShutdownExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        // 错误：忘记关闭线程池
        // executor.shutdown();
    }
}

问题说明：
程序中创建了一个固定大小的线程池，但没有调用executor.shutdown()方法来关闭线程池。
这将导致线程池中的线程一直保持活动状态，即使所有任务已经完成，程序也不会终止。

2. 使用无界队列

错误代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
 * UnboundedQueueExample
 * @author senfel
 * @version 1.0
 * @date 2024/10/24 11:22
 */
public class UnboundedQueueExample {
    public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(
                2, 2, 0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>()
        );

        for (int i = 0; i < 1000; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}

问题说明：
使用了LinkedBlockingQueue作为工作队列，这是一个无界队列。
当任务提交速度远大于任务处理速度时，队列会无限增长，最终可能导致内存溢出。

3. 提交的任务抛出未捕获的异常

错误代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * UncaughtExceptionExample
 * @author senfel
 * @version 1.0
 * @date 2024/10/24 11:23
 */
public class UncaughtExceptionExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                if (taskId == 5) {
                    throw new RuntimeException("Task 5 failed");
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}

问题说明：
在任务中抛出了一个未捕获的异常。
如果不捕获和处理这些异常，线程池可能会默默地忽略这些异常，导致后续任务无法正常执行。

总结

Java线程池是一种强大的多线程管理工具，通过合理选择和配置线程池类型，可以显著提高应用程序的性能和稳定性。本文介绍了四种常见的线程池类型及其示例代码，并分析了一些常见的错误案例。为了避免这些问题，建议：
①始终调用shutdown()方法来关闭线程池。
②使用有界队列来限制任务队列的大小。
③捕获和处理任务中的异常，确保线程池的稳定运行。
希望本文能帮助读者更好地理解和使用Java线程池。

JUC的Executors类的4种线程池及相关面试点
の博客
06-04 86
四种线程池面试题
Java开发常见面试题详解（并发，JVM）
热门推荐
KISS
03-12 8万+
预览 并发 问题 详解 请谈谈你对volatile的理解 link CAS你知道吗？ link 原子类Atomiclntegerl的ABA问题谈谈?原子更新引用知道吗？ link 我们知道ArrayList是线程不安全，请编码写一个不安全的案例并给出解决方案 link 公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁 link CountDownLatch/CyclicBarrier/Semaphore使用过吗？ link 阻塞队列知道吗？ l
Executors创建线程池的问题
stormkai的专栏
02-21 543
Executors创建线程池存在的问题
Java线程池ExecutorService学习和使用
Dd_ddc的博客
07-17 3099
线程池中有3个线程 (pool-1-thread-1、pool-1-thread-2 和 pool-1-thread-3)，每个线程可以同时执行一个任务。如果需要每个任务执行之后需要返回一个结果，可以实现Callable接口并重写call方法。每个任务执行的过程包括打印任务开始的信息、模拟执行2秒、打印任务完成的信息。每个任务执行2秒，然后完成，接着线程池中的线程会继续执行等待中的任务。前3个任务会立即被分配给线程池中的3个线程并开始执行。使用一个固定大小为3的线程池来并发执行这些任务。
【多线程】为什么不建议使用Executors来创建线程池？
王佑辉的博客
04-22 1007
单个线程线程池创建时FinalizableDelegatedExecutorService用的是装饰器模式，只对外暴露ExecutorService接口，不能调用ThreadPoolExecutor中特有的方法，固定数量线程池对外暴露的是ThreadPoolExecutor对象，可以强转，调用setCorePoolSize等方法进行修改。4.与自己创建的线程的区别：a.自己创建一个单线程串行执行任务，任务执行失败而终止则没有任务不就措施，线程池执行失败会新建一个线程，保证线程池的正常工作;
Java线程池
yuzheh521的博客
04-24 900
线程池使 java中经常需要用到多线程来处理一些业务，我们非常不建议单纯使用继承Thread或者实现Runnable接口的方式来创建线程，那样势必有创建及销毁线程耗费资源、线程上下文切换问题。同时创建过多的线程也可能引发资源耗尽的风险，这个时候引入线程池比较合理，方便线程任务的管理。java中涉及到线程池的相关类均在jdk1.5开始的java.util.concurrent包中， 涉及到的几个核心类及接口包括： Executor、 Executors、 ExecutorService、 Thre
ThreadPoolExecutor详解-FixedThreadPool
onefly
07-10 1万+
FixedThreadPool类型的线程池由Executors创建
java 线程池详解
最新发布
03-01
### Java 线程池详解 #### 创建线程池的方式 Java 提供了几种创建线程池的方法，最常用的是通过 `Executors` 工厂类来获取预配置好的线程池实例。然而，在实际项目中更推荐使用 `ThreadPoolExecutor` 构造器来自...
Java线程池的并发工具类详解
线程池是一种用来管理和复用线程的机制。它在应用程序启动时创建一组预定义的线程，并维护一个任务队列。当有新任务到达时，线程池中的线程会处理任务队列中的任务，从而实现异步处理，提升程序的性能和响应速度。 ...
Java线程池使用指南：如何避免9种常见陷阱并提升系统稳定性
[Java线程池使用指南：如何避免9种常见陷阱并提升系统稳定性](https://img-blog.csdnimg.cn/fc3011f7a9374689bc46734c2a896fee.png) # 1. Java线程池基础 Java线程池是Java并发编程中非常重要的一个概念，它允许...
定时任务执行的几种常见方式
qq_42391042的博客
05-18 2392
Spring项目里面执行定时任务
线程池介绍：ThreadPoolExecutor
iiiiiiiiiooooo的博客
02-28 887
线程池介绍 为什么要线程池 多线程技术主要解决处理器单元内多个线程执行的问题，可以减少处理器单元的闲置时间，增加处理器单元吞吐能力，多线程的情况下确实可以最大限度发挥多核处理器的计算能力，但是如果随意使用线程，对系统性能反而不利 创建和销毁线程需要时间：假如一个服务器完成意向任务所需要的时间为：T1表示线程创建时间，T2表示线程执行任务时间，T3表示销毁时间，如果T1+T3远大于T2，那么会得不偿失 线程也需要占用内存空闲，大量的线程会抢占宝贵的内存资源，可能会导致OOM的异常 大量的线程回收也会给
Java并发39:Executor系列--ScheduleExecutorService接口学习笔记
韩超的博客 (hanchao5272)
04-06 4561
[超级链接：Java并发学习系列-绪论] 本章主要学习ScheduleExecutorService接口。 1.ScheduleExecutorService接口概述 @since 1.5 ScheduledExecutorService继承自ExecutorService，它可以在给定延时之后调度任务，也可以以指定的周期调度任务。 schedule()方法可以创建含有延时(dela...
秒懂 ScheduledThreadPoolExecutor
二师兄撒欢之地
01-13 169
ScheduledThreadPoolExecutor 扩展自 一文秒懂 Java 线程池之 ThreadPoolExecutor 讲解的 了ThreadPoolExecutor 类，并且添加了其它方法实现了 ScheduledExecutorService 接口。
Executors创建线程池的弊端
admin1973的专栏
12-01 5057
Executors创建线程池的弊端 线程池不允许使用Executors去创建,而是通过ThreadPoolExecutor的方式, 这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险. 说明:Executors的各个方法的弊端: 1)newFixedThreadPool和newSingleThreadExecutor: 主要问题是堆积的请求处理队列可能会耗费非常大的
java-Exectors提供的四种基本线程池用法与比较详解
zhizhuodewo6的博客
07-07 1977
线程池算是Android开发中非常常用的一个东西了，只要涉及到线程的地方，大多数情况下都会涉及到线程池。Android开发中线程池的使用和Java中线程池的使用基本一致。那么今天我想来总结一下android开发中线程池的使用。 OK，假如说我想做一个新闻应用，ListView上有一个item，每个item上都有一张图片需要从网络上加载，如果不使用线程池，你可能通过下面的方式来开启
为什么阿里巴巴要禁用Executors创建线程池？
Java笔记虾
11-08 2845
看阿里巴巴开发手册并发编程这块有一条：线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，通过源码分析禁用的原因 写在前面 首先感谢大家在盖楼的间隙阅读本篇文章，通过阅读本篇文章你将了解到： 线程池的定义 Executors创建线程池的几种方式 ThreadPoolExecutor对象 线程池执行任务逻辑和线程池参...
JAVA线程池工厂Executors的局限性
angry_tiger的博客
03-09 655
       JDK提供了一些列比较成熟的线程池的管理工具,其中的Executors就是其中的杰出代表, 非常简洁的方法调用,确提供了很好的线程池功能,很显然任何东西都有其特定的适用场景, Executors特点易于使用,但是它可能对高并发的任务执行的场景,会带来灾难性的问题,这一切也源于它优点。      稍微看一下Executors类就知道, 该类几乎提供了一站式的方法,所有创建线程池方法几乎...
使用JAVA的ExecutorService来限制线程数量
王命风的博客
10-30 1万+
前言 诸如利用多线程并行访问数据库可以提高系统的并发性能，但是线程变多伴随而来的是，当线程数大于DBMS（数据库管理系统）设置的最大DB连接数时，程序就挂掉了。在JAVA中如何避免这种问题呢？ 解决方法 使用ExecutorService，限制最大线程数量 ExecutorService是？ ExecutorService是JAVA标准的并行计算库[java.util.concurren
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小沈同学呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值