Java线程池的使用

最新推荐文章于 2025-11-26 11:24:10 发布
原创 最新推荐文章于 2025-11-26 11:24:10 发布 · 2k 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #java #spring

Java线程池的使用

线程池就是放了线程的池子，它可以对池子里面的线程进行维护，有效避免了重复创建线程和销毁线程所耗费的时间

线程的七大参数

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {...}

corePoolSize：核心线程数，也就是线程池中的常驻线程，不管是否空闲都在池中，除非设置allowCoreThreadTimeOut，在超时时才会干掉核心线程
maximumPoolSize：线程池中允许的最大线程数
keepAliveTime：空闲线程的存活时间，这里是指除了核心线程外的空闲线程的存活时间，就算核心线程有空闲也不会被干掉
unit：keepAliveTime的单位
workQueue：任务队列，存提交但尚未执行的任务
threadFactory：创建线程的工厂
handler：拒绝策略，意思是当队列已满，并且最大线程数都在工作时执行拒绝策略

线程的执行流程

在这里插入图片描述

常用的三种线程池

单个线程

public class ThreadPool {
    public static void main(String[]args){
        //1、单个线程
        ExecutorService executorService= Executors.newSingleThreadExecutor();

        //2、多个线程，可自定义多少个线程
        //ExecutorService executorService=Executors.newFixedThreadPool(5);

        //3、没有边界的线程，因为线程个数是Integer.MAX_VALUE
        //ExecutorService executorService=Executors.newCachedThreadPool();
        for(int i=0;i<=10;i++){
            final int j=i;
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName()+"\t"+j);
            });
        }
        //executorService.shutdown();
    }
}

结果
在这里插入图片描述

自定义线程个数

public class ThreadPool {
    public static void main(String[]args){
        //1、单个线程
        //ExecutorService executorService= Executors.newSingleThreadExecutor();

        //2、多个线程，可自定义多少个线程
        ExecutorService executorService=Executors.newFixedThreadPool(5);

        //3、没有边界的线程，因为线程个数是Integer.MAX_VALUE
        //ExecutorService executorService=Executors.newCachedThreadPool();
        for(int i=0;i<=10;i++){
            final int j=i;
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName()+"\t"+j);
            });
        }
        //executorService.shutdown();
    }
}

结果，最大线程只有五个，可以从线程名字看出来
在这里插入图片描述

无边界线程个数

因为newCachedThreadPool内部实现的最大线程为Integer.MAX_VALUE，可以认为是无边界的

public class ThreadPool {
    public static void main(String[]args){
        //1、单个线程
        //ExecutorService executorService= Executors.newSingleThreadExecutor();

        //2、多个线程，可自定义多少个线程
        //ExecutorService executorService=Executors.newFixedThreadPool(5);

        //3、没有边界的线程，因为线程个数是Integer.MAX_VALUE
        ExecutorService executorService=Executors.newCachedThreadPool();
        for(int i=1;i<=10;i++){
            final int j=i;
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName()+"\t"+j);
                try {
                    //稍微睡眠几毫秒，可以更清楚的看到使用的线程数
                    TimeUnit.MILLISECONDS.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        //executorService.shutdown();
    }
}

从线程名字可以看出这里开了10个线程执行任务
在这里插入图片描述

自定义线程池的四种拒绝策略

第一种 AbortPolicy

ThreadPoolExecutor.AbortPolicy()是默认的拒绝策略，使用这个策略会直接抛出RejectedExecutionException 异常

public class ThreadPool {
    public static void main(String[]args){
        //1、单个线程
        //ExecutorService executorService= Executors.newSingleThreadExecutor();

        //2、多个线程，可自定义多少个线程
        //ExecutorService executorService=Executors.newFixedThreadPool(5);

        //3、没有边界的线程，因为线程个数是Integer.MAX_VALUE
        //ExecutorService executorService=Executors.newCachedThreadPool();

        //4、自定义线程池,当提交的任务个数大于最大线程数+队列任务数时会执行拒绝策略
        ExecutorService executorService=new ThreadPoolExecutor(3,
                5,
                10L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        for(int i=1;i<=11;i++){
            final int j=i;
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName()+"\t"+j);
            });
        }
        //executorService.shutdown();
    }
}

在这里插入图片描述

第二种 CallerRunsPolicy

执行这个策略时，调用者自己运行任务

public class ThreadPool {
    public static void main(String[]args){

        //自定义线程池,当提交的任务个数大于最大线程数+队列任务数时会执行拒绝策略
        ExecutorService executorService=new ThreadPoolExecutor(3,
                5,
                10L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        for(int i=1;i<=11;i++){
            final int j=i;
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName()+"\t"+j);
            });
        }
        //executorService.shutdown();
    }
    
}

这里可以看到主线程在运行一个任务
在这里插入图片描述

第三种 DiscardOldestPolicy

执行这个策略时，会把队列中等待时间最长的任务抛掉，然后把新任务加入队列

public class ThreadPool {
    public static void main(String[]args){

        //自定义线程池,当提交的任务个数大于最大线程数+队列任务数时会执行拒绝策略
        ExecutorService executorService=new ThreadPoolExecutor(3,
                5,
                10L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        for(int i=1;i<=11;i++){
            final int j=i;
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName()+"\t"+j);
            });
        }
        //executorService.shutdown();
    }
}

我们总共提交了11个任务，但在这里只有10个任务，也就是说新加入的11把4给替换掉了
在这里插入图片描述

第四种 DiscardPolicy

如果线程池满了，直接把新提交的任务抛掉

public class ThreadPool {
    public static void main(String[]args){

        //自定义线程池,当提交的任务个数大于最大线程数+队列任务数时会执行拒绝策略
        ExecutorService executorService=new ThreadPoolExecutor(3,
                5,
                10L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());
        for(int i=1;i<=11;i++){
            final int j=i;
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName()+"\t"+j);
            });
        }
        //executorService.shutdown();
    }
}

从下面可以看到11的任务直接被抛掉了
在这里插入图片描述

合理配置线程数

1、CPU密集型
线程个数=CPU核数+1
2、IO密集型
有两种：
线程个数=CPU核数*2
线程个数=CPU核数/1-阻塞系数，阻塞系数0.8-0.9

牧歌ing
关注
Java线程池ThreadPoolExecutor背后的秘密与实践
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
05-12 170万+
本文深入分析了Java线程池ThreadPoolExecutor的工作原理、核心参数以及配置策略。通过详细讲解线程池的创建、任务调度和线程管理机制，帮助开发者理解如何高效使用线程池来处理并发任务。文章还探讨了常见的性能瓶颈和优化方法，如合理配置线程池参数、选择适当的拒绝策略等，旨在提升应用的并发处理能力和稳定性。最终，读者将能够根据不同场景灵活调整线程池配置，从而有效提升系统性能。
Java线程池详解
who_im_i的博客
06-30 1018
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。虽然我们可以使用new的方式去创建线程，但若是并发线程太高，每个线程执行时间不长，这样频繁的创建销毁线程是比较耗费资源的，同时也不方便管理，线程池的出现就是为了解决上述问题。
Java线程池使用说明
02-24
Java线程池使用说明Java线程池使用说明Java线程池使用说明
Java如何使用异步编排任务和线程池？
一个勤勤恳恳的程序猿
09-16 992
文章目录 一、如何创建线程池？ 1、七大参数介绍 1）corePoolSize 2）maximumPoolSize 3）keepAliveTime 4）unit 5）workQueue 6）threadFactory 7）handler 二、CompletableFeture异步编排 1、创建异步对象的方式2、计算完成时回调的方法3、handle方法4、线程串行化方法二、使用步骤1.引入库2.读入数据总结 一、如何创建线程池？ 1、七大参数介绍 1）
【005】万字长文: 什么是线程池？在Java中如何使用线程池？
最新发布
编程技术圈
11-26 1825
线程池是一种复用线程、降低资源开销的并发工具。Java中通过Executor框架实现，推荐使用ThreadPoolExecutor手动创建（可灵活配置核心线程数、队列和拒绝策略），而非Executors工具类（存在OOM风险）。线程池核心思想是复用线程，避免频繁创建销毁，提高响应速度并便于管理。使用时需提交Runnable/Callable任务，并注意合理关闭线程池。
Java线程池详解(创建、使用场景、参数详解)
千层冷面的博客
02-26 1821
Java中的线程池（ThreadPoolExecutor）是并发编程中非常重要的工具，用于管理和复用线程，避免频繁创建和销毁线程带来的性能开销。Java通过java.util.concurrent包提供了丰富的线程池实现。
java线程池的使用
小明的博客
05-18 512
如何你直接想使用线程池请滑到最后。
JAVA线程池的使用
weixin_68320784的博客
03-31 4651
一、使用 Executors 创建线程池 Executors是一个线程池工厂类，里面有许多静态方法，供开发者调用。 /* 该方法返回一个固定线程数量的线程池，该线程池池中的线程数量始终不变。 * 当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。 * 若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务 * 默认等待队列长度为Integer.MAX_VALUE */ ExecutorService fixedThreadPool = Executors
java线程池使用后到底要关闭吗
08-26
java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术，可以帮助开发者更好地管理线程资源，提高系统的性能和可靠性。然而，在使用java线程池时，一个常见的问题是：使用完线程池后到底要不要关闭？...
Java线程池使用与原理详解
08-29
Java线程池使用与原理详解 Java线程池是Java语言中的一种高级机制，用于管理和复用线程，以提高程序的执行效率和性能。本文将详细介绍Java线程池的使用和原理，包括线程池的概念、线程池的优点、线程池的创建、...
java线程池使用
m0_63803244的博客
07-15 2038
将线程事先创建好，交给线程池管理，当有任务时，分配线程池中的线程执行任务。返回任务队列中的线程，开发者自行处理没有执行的任务。这些任务只能是实现callable接口的有返回值的任务。invokeany（）方法，一旦有任务直接完，其他任务都不执行了，返回最先完成任务的返回值。（1）get（）方法：阻塞方法，获取任务执行结果的线程会一直等到任务执行完毕。可能的异常：任务被取消、任务抛出异常、执行任务的线程中断、等待任务执行超时。stop：线程池准备关闭，不接受新任务，终止池中任务，不处理任务队列的任务。
java中线程池的使用
diaojin6880的博客
09-21 186
public static ExecutorSevice newSingleThreadExecutor() public static ExecutorSevice newFixedThreadPool() public static ExecutorSevice newCachedThreadPool() public static Sched...
java 线程池的使用
qq_20302017的博客
12-10 1235
java 线程池的使用 1.线程池的概念 线程池： Java通过Executors提供四种线程池，分别为：    newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 newScheduledThre
java线程池使用说明
lvshilei13134的专栏
07-11 774
看到一篇不错的文章 分享给大家 一 简介 线程的使用在java中占有极其重要的地位，在jdk1.4极其之前的jdk版本中，关于线程池的使用是极其简陋的。在jdk1.5之后这一情况有了很大的改观。Jdk1.5之后加入了java.util.concurrent包，这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助。 二：线程池 线程池的作用：
线程池的4种创建方式
qq_35657661的博客
12-20 1097
线程池四种创建方式 Java通过Executors（jdk1.5并发包）提供四种线程池，分别为： newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 newScheduledThreadPool 创建一个定长线...
Java 线程池使用
03-11
<think>好的，我需要回答用户关于如何在Java中使用线程池的问题，包括示例代码和最佳实践。首先，我应该回顾用户提供的引用内容，看看有没有相关的信息可以利用。 根据引用[1]，提到了Java线程池的使用实例、最佳实践以及代码示例。引用[2]讨论了为什么使用线程池、如何使用以及遇到的坑。引用[3]则集中在最佳实践和异常处理方面。这些引用应该能提供足够的信息来构建回答。 首先，我需要解释线程池的基本概念和为什么要使用线程池，比如资源复用、控制并发数、管理线程生命周期等。然后，介绍Java中创建线程池的方法，特别是通过Executors工厂类提供的几种常见线程池类型，比如FixedThreadPool、CachedThreadPool、SingleThreadExecutor等，但也要提到推荐直接使用ThreadPoolExecutor来创建，以便更灵活地控制参数，避免资源耗尽的风险，这点在引用[3]中有提到。 接下来，给出一个示例代码。根据引用[1]中的示例，可能需要展示如何通过ThreadPoolExecutor来创建线程池，设置核心线程数、最大线程数、队列容量等参数，并演示如何提交任务。同时，需要强调在阿里巴巴开发规范中推荐手动创建线程池，而不是使用Executors，这点可能来自引用[3]中的最佳实践。 然后，讨论最佳实践，比如合理配置线程数、使用有界队列、处理未捕获异常、正确关闭线程池等。这些内容在引用[3]中有涉及，比如异常处理和分析的重要性，以及关闭线程池的方法。 此外，要注意线程池的任务拒绝策略，如AbortPolicy、CallerRunsPolicy等，并说明在不同场景下如何选择合适的策略。这部分可能需要结合引用[2]中提到的使用过程中遇到的坑。 最后，生成相关问题，可能包括线程池的参数配置、不同线程池类型的区别、如何监控线程池状态、常见的线程池问题排查等，确保问题与用户查询内容相关，并帮助深化理解。 需要确保回答结构清晰，分步骤说明，代码正确，并且引用正确的位置。例如，在提到线程池参数配置时，引用[3]中的最佳实践；在提到任务拒绝策略时，引用[2]中的实际应用经验。 现在需要将以上思考整理成中文回答，确保符合用户要求的格式，使用正确的LaTeX语法，并在适当的位置添加引用标识。</think>### 如何在Java中使用线程池？ #### 1. **线程池的作用与优势** - **资源复用**：避免频繁创建/销毁线程，提升性能[^2]。 - **控制并发**：通过核心线程数、最大线程数限制资源占用[^3]。 - **任务管理**：使用队列缓冲任务，支持拒绝策略处理过载[^1]。 #### 2. **创建线程池** Java推荐通过`ThreadPoolExecutor`手动配置参数（而非`Executors`工厂类，避免潜在风险）[^3]： ```java int corePoolSize = 5; // 核心线程数 int maxPoolSize = 10; // 最大线程数 long keepAliveTime = 60L; // 空闲线程存活时间（秒） BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(100); // 有界队列 ThreadPoolExecutor executor = new ThreadPoolExecutor( corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.SECONDS, queue, new ThreadPoolExecutor.AbortPolicy() // 默认拒绝策略：直接抛出异常 ); ``` #### 3. **提交任务** - 使用`execute()`提交`Runnable`任务： ```java executor.execute(() -> { System.out.println("Task executed by " + Thread.currentThread().getName()); }); ``` - 使用`submit()`提交`Callable`任务（可获取返回值）： ```java Future<String> future = executor.submit(() -> { return "Result from thread " + Thread.currentThread().getName(); }); System.out.println(future.get()); // 阻塞获取结果 ``` #### 4. **最佳实践** - **参数配置**： - CPU密集型任务：核心线程数 ≈ CPU核心数[^3]。 - I/O密集型任务：核心线程数可适当增加（如2倍CPU核心数）。 - 使用有界队列避免内存溢出[^3]。 - **异常处理**： ```java executor.setRejectedExecutionHandler((r, executor) -> { // 自定义拒绝策略，如记录日志或降级处理 }); // 任务内捕获异常 executor.execute(() -> { try { // 业务逻辑 } catch (Exception e) { // 记录异常 } }); ``` - **关闭线程池**： ```java executor.shutdown(); // 等待已提交任务完成 // executor.shutdownNow(); // 立即终止所有任务（慎用） ``` #### 5. **常用线程池类型** - **FixedThreadPool**：固定线程数，适用于负载较重的场景。 ```java ExecutorService fixedPool = Executors.newFixedThreadPool(5); ``` - **CachedThreadPool**：弹性线程数，适合短时异步任务[^1]。 - **ScheduledThreadPool**：支持定时/周期性任务。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值