线程池的3个常用方式

本文介绍了Java中三种线程池的使用方式:固定长度线程池(处理定长并发)、单线程化线程池(保证任务顺序执行)和可缓存线程池(动态调整线程)。通过示例展示了ExecutorService在不同场景下的应用,以及它们各自的特性。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1.为什么要用线城池,优势?

2.应用方式

package com.thread;


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

/**
 *Java中的线程池是通过 Executor来实现的,该框架用到了Executor,Executors,ExecutorService,ThreadPoolExecutor
 * 这几个类
 *
 *
 * 线程池的3种应用方式
 *
 */
public class MyThreadPoolDemo {
    public static void main(String[] args) {

        /**
         *
         *     public static ExecutorService newFixedThreadPool(int nThreads) {
         *         return new ThreadPoolExecutor(nThreads, nThreads,
         *                                       0L, TimeUnit.MILLISECONDS,
         *                                       new LinkedBlockingQueue<Runnable>());
         *     }
         *
         * 主要特点:
         * 1.创建一个定长的线程池,可控制最大并发数,超出的线程会在队列中等待
         *
         * 2.newFixedThreadPool创建线程中 coolPoolSize 和 maxiMumPoolSize 值是相等的它使用的LinkedBlockQueue
         *
         */
        ExecutorService executorService = Executors.newFixedThreadPool(5); //一池5个线程处理


        /**
         *    public static ExecutorService newSingleThreadExecutor() {
         *         return new FinalizableDelegatedExecutorService
         *             (new ThreadPoolExecutor(1, 1,
         *                                     0L, TimeUnit.MILLISECONDS,
         *                                     new LinkedBlockingQueue<Runnable>()));
         *     }
         *
         *    主要特点:
         *    1.创建一个单一线程化的线程池,它只会用唯一的工作线程 来执行任务,保证所有的任务按照指定的线程来执行
         *
         *    2.newSingleThreadExecutor 中将 coolPoolSize 和 maxiMumPoolSize都设置为1 它使用的是 LinkedBlockingQueue
         */
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();//一池一个线程

        /**
         *
         *  public static ExecutorService newCachedThreadPool() {
         *         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
         *                                       60L, TimeUnit.SECONDS,
         *                                       new SynchronousQueue<Runnable>());
         *     }
         *
         *   主要特点:
         *   1.创建一个可以缓存的线程池,如果线程长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程
         *   2.newCachedThreadPool 将coolPoolSize 设置成 0 将maxiMumPoolSize设置为 Integer.MAX_VALUE
         *   使用了SynchronousQueue 也就是说 来了任务就创建线程运行 当空闲60S后 就销毁线程
         *
         */
        ExecutorService executorService2 = Executors.newCachedThreadPool();//一池N个线程

        //10个用户来创办业务,每一个用户就是来自外部的请求线程
         try {
             for (int i = 1; i <=10 ; i++) {
                 executorService.execute(()->{
                     System.out.println(Thread.currentThread().getName()+"\t 办理业务");
                 });
//                  try {
//                        TimeUnit.MILLISECONDS.sleep(200);
//                       } catch (Exception e) {
//                        e.printStackTrace();
//                    }
             }
              } catch (Exception e) {
               e.printStackTrace();
           }finally {
             executorService.shutdown();
         }


    }
}

 executorService的输出结果

 pool-1-thread-1     办理业务
pool-1-thread-3     办理业务
pool-1-thread-2     办理业务
pool-1-thread-2     办理业务
pool-1-thread-5     办理业务
pool-1-thread-3     办理业务
pool-1-thread-1     办理业务
pool-1-thread-4     办理业务
pool-1-thread-5     办理业务
pool-1-thread-2     办理业务

executorService1的输出结果

pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务
pool-1-thread-1     办理业务

executorService2的输出结果

pool-1-thread-1     办理业务
pool-1-thread-4     办理业务
pool-1-thread-3     办理业务
pool-1-thread-2     办理业务
pool-1-thread-7     办理业务
pool-1-thread-6     办理业务
pool-1-thread-5     办理业务
pool-1-thread-8     办理业务
pool-1-thread-8     办理业务
pool-1-thread-1     办理业务

 

<think>好的,我现在需要回答用户关于线程池常用队列类型的问题。首先,我要回顾一下用户提供的引用内容,确保信息准确。 根据引用[1],线程池的队列类型直接影响行为和性能,包括无界队列、有界队列、优先级队列和同步队列。引用[3]提到LinkedBlockingQueue作为无界队列用于FixedThreadPool和SingleThreadExecutor。引用[4]对比了ArrayBlockingQueue和LinkedBlockingDeque的不同处理机制。引用[5]指出PriorityBlockingQueue和DelayQueue用于特定场景。此外,引用[2]介绍了ForkJoinPool的不同之处,但可能和队列类型关联不大。 接下来需要整理这些队列类型的特点、应用场景及示例。需要注意格式要求,如行内公式用$...$,独立公式用$$...$$,但这里可能数学公式较少。需要结构清晰,分点说明,每个类型包括定义、特点、应用场景和示例代码(如果有的话)。同时生成相关问题。 需要确保语言准确,比如区分有界和无界队列的容量限制,同步队列的即时处理机制,优先级队列的排序方式等。还要注意引用标注,在每部分末尾自然添加对应的引用标识。例如,提到无界队列时引用[1]和[3],有界队列引用[1][4],同步队列引用[1][4],优先级队列引用[1][5],延迟队列引用[5]。 最后,生成的相关问题应覆盖队列类型的选择、对比、性能影响、特定场景应用以及与其他线程池组件的关系。确保问题与回答内容相关,帮助用户深入理解。</think>### 线程池常用队列类型总结 线程池的任务队列类型直接影响任务调度策略和系统性能,以下是五种常见队列类型的对比分析: --- #### 1. **无界队列(LinkedBlockingQueue)** - **定义**:基于链表实现,默认容量为$Integer.MAX\_VALUE$(约21亿),可视为无界队列。 - **特点**: - 允许无限添加任务,不会触发拒绝策略[^3]。 - 适用于**任务量波动大但需保证任务不丢失**的场景,如后台日志处理。 - **应用场景**:Java的`FixedThreadPool`和`SingleThreadExecutor`默认使用此队列。 - **示例**: ```java ExecutorService executor = Executors.newFixedThreadPool(4); ``` --- #### 2. **有界队列(ArrayBlockingQueue)** - **定义**:基于数组实现,需指定固定容量(如1000)。 - **特点**: - 队列满时触发线程池扩容(新增线程直至达到`maximumPoolSize`),若仍满则触发拒绝策略[^4]。 - **平衡资源控制与突发流量**,避免内存溢出。 - **应用场景**:高并发系统中需限制资源使用的场景,如电商秒杀系统。 - **示例**: ```java new ThreadPoolExecutor(4, 8, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100)); ``` --- #### 3. **同步移交队列(SynchronousQueue)** - **定义**:不存储任务,直接将任务移交空闲线程。 - **特点**: - 队列无容量,任务提交后若无线程空闲则立即失败[^4]。 - 强制线程池快速扩容,适合**短时高吞吐任务**。 - **应用场景**:Java的`CachedThreadPool`默认使用此队列。 - **示例**: ```java ExecutorService executor = Executors.newCachedThreadPool(); ``` --- #### 4. **优先级队列(PriorityBlockingQueue)** - **定义**:支持按优先级排序任务(需实现`Comparable`接口)。 - **特点**: - 任务执行顺序由优先级决定,而非提交顺序[^5]。 - 适用于**任务重要性分层**的场景,如实时监控系统。 - **示例**: ```java new ThreadPoolExecutor(2, 4, 10, TimeUnit.SECONDS, new PriorityBlockingQueue<>()); ``` --- #### 5. **延迟队列(DelayQueue)** - **定义**:任务需实现`Delayed`接口,按延迟时间排序。 - **特点**: - 任务在指定延迟后才会被取出执行。 - 适用于**定时任务调度**,如订单超时取消。 - **示例**: ```java ScheduledExecutorService executor = Executors.newScheduledThreadPool(2); executor.schedule(() -> System.out.println("Delayed task"), 5, TimeUnit.SECONDS); ``` --- ### 队列选择对比表 | 队列类型 | 容量限制 | 拒绝策略触发条件 | 典型应用场景 | |---------------------|----------|------------------------|----------------------| | LinkedBlockingQueue | 无界 | 永不触发 | 流量波动大的后台任务 | | ArrayBlockingQueue | 有界 | 队列满且线程数达上限 | 高并发资源受限系统 | | SynchronousQueue | 零容量 | 无空闲线程且线程数达上限 | 短时高吞吐任务 | | PriorityBlockingQueue | 无界 | 永不触发 | 优先级任务调度 | | DelayQueue | 无界 | 永不触发 | 定时任务 | --- ### 关键设计原则 - **无界队列风险**:可能导致内存溢出(如持续积压任务)[^1]。 - **有界队列优化**:需结合`maximumPoolSize`和拒绝策略(如`CallerRunsPolicy`)防止任务丢失[^4]。 - **同步队列代价**:频繁创建/销毁线程会增加开销,需设置合理的空闲超时时间[^2]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值