java 线程池详解

最新推荐文章于 2026-05-01 10:24:02 发布
原创 最新推荐文章于 2026-05-01 10:24:02 发布 · 957 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java线程池详解

为什么要使用线程池？

  • 为了减少资源的开销，提高系统性能
  • 先创建好线程，如果需要使用从池中取，提高利用率
  • 控制线程数量，防止程序崩溃

Java 中创建线程池的两种方式？

  1. 使用ThreadPoolExecutor类
  2. 使用Executors类 

其实这两种方式在本质上是一种方式，都是通过ThreadPoolExecutor类的方式

一、ThreadPoolExecutor的方式

1、使用方法

查看JDK的源码，ThreadPoolExecutor类提供了以下构造方法

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

   
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

构造方法参数说明：

  • corePoolSize：线程池的核心线程数
  • maximumPoolSize：线程池的最大线程数
  • keepAliveTime：线程池空闲时线程的存活时间
  • unit：线程池存活时间单位
  • workQueue：存放任务队列，使用的是阻塞队列
    • rrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
    • LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。
    • PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。
    • DelayQueue：一个使用优先级队列实现的无界阻塞队列。
    • SynchronousQueue：一个不存储元素的阻塞队列。
    • LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。
    • LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
    • 方法处理方式    抛出异常    返回特殊值    一直阻塞    超时退出
      插入方法           add(e)        offer(e)           put(e)       offer(e,time,unit)
      移除方法           remove()     poll()             take()        poll(time,unit)
      检查方法           element()    peek()           不可用       不可用
       
  • threadFactory：线程池创建线程的工厂
  • handler：在队列（workQueue）和线程池达到最大线程数（maximumPoolSize）均满时仍有任务的情况下的处理方

四个拒绝策略：

ThreadPoolExecutor.AbortPolicy():丢弃任务并抛出RejectedExecutionException异常。

ThreadPoolExecutor.DiscardPolicy()：丢弃任务，但是不抛出异常。

ThreadPoolExecutor.DiscardOldestPolicy()：丢弃队列最前面的任务，然后重新提交被拒绝的任务

ThreadPoolExecutor.CallerRunsPolicy()：由调用线程（ 直接调用run方法并且阻塞执行）处理该任务

查看java.util.concurrent.ThreadPoolExecutor类的源码:


    /**
     * The default rejected execution handler
     */
    private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();

线程池的默认拒绝策略为AbortPolicy，即丢弃任务并抛出RejectedExecutionException异常。测试代码：

ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(100);
        ThreadFactory factory = f-> new Thread(f,"thread-pool-test");
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5,
                0L, TimeUnit.SECONDS, queue, factory);
        while (true){
            executor.submit(()->{
                System.out.println(queue.size());
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

线程池拒绝策略DiscardPolicy，丢弃任务，但是不抛出异常。如果线程队列已满，则后续提交的任务都会被丢弃，且是静默丢弃。

使用此策略，可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略。

测试代码：

 ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(100);
        ThreadFactory factory = f-> new Thread(f,"thread-pool-test");
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5,
                0L, TimeUnit.SECONDS, queue, factory, new ThreadPoolExecutor.DiscardPolicy());
        while (true){
            executor.submit(()->{
                System.out.println(queue.size());
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

线程池拒绝策略DiscardOldestPolicy，丢弃队列最前面的任务，然后重新提交被拒绝的任务。

此拒绝策略，是一种喜新厌旧的拒绝策略。是否要采用此种拒绝策略，还得根据实际业务是否允许丢弃老任务来认真衡量

测试代码：

 ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(100);
        ThreadFactory factory = f-> new Thread(f,"thread-pool-test");
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5,
                0L, TimeUnit.SECONDS, queue, factory, new ThreadPoolExecutor.DiscardOldestPolicy());
        while (true){
            executor.submit(()->{
                System.out.println(queue.size());
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

线程池拒绝策略CallerRunsPolicy，由调用线程处理该任务

如果任务被拒绝了，则由调用线程（提交任务的线程）直接执行此任务，我们可以通过代码来验证这一点：

测试代码：

 ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(100);
        ThreadFactory factory = f -> new Thread(f, "thread-pool-test");
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5,
                0L, TimeUnit.SECONDS, queue, factory, new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + ":执行任务");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

通过结果可以看到，主线程main也执行了任务，这正说明了此拒绝策略由调用线程（提交任务的线程）直接执行被丢弃的任务的。

二、Executors的方式

1、使用方法

Executors类提供了下面的构造方法，

 

前面说Executors类通过ThreadPoolExecutor类的方式实现的，但是我们看到的返回值类型确实ExecutorService，这不是我们要的ThreadPoolExecutor，那么我们查看下他们之间的关系

可以看到ThreadPoolExecutor继承了AbstractExecutorService，AbstractExecutorService抽象类实现了ExecutorService接口，那么ThreadPoolExcutor和ExecutorService就有了关系。

那么我们在查看ExecutorService 的具体实现：

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

可以看到返回的是ThreaPoolExecutor对象，调用的是ThreaPoolExecutor类的构造方法。

newCachedThreadPool 创建一个可缓存的线程池，如果线程池长度超过处理需求，可灵活收回空闲的线程，若无回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程并发数，超过的线程会在队列中等待。

ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Date date = new Date();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    System.out.println(sdf.format(date) + "---"+ Thread.currentThread().getName() + "   i=" + temp);
                }
            });
        }

执行结果：

2020-01-09 15:47:20---pool-1-thread-2   i=1
2020-01-09 15:47:20---pool-1-thread-1   i=0
2020-01-09 15:47:20---pool-1-thread-3   i=2
2020-01-09 15:47:21---pool-1-thread-2   i=3
2020-01-09 15:47:21---pool-1-thread-1   i=4
2020-01-09 15:47:21---pool-1-thread-3   i=5
2020-01-09 15:47:22---pool-1-thread-1   i=7
2020-01-09 15:47:22---pool-1-thread-3   i=8
2020-01-09 15:47:22---pool-1-thread-2   i=6
2020-01-09 15:47:23---pool-1-thread-1   i=9

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行

public class Test {

    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        executor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(sdf.format(new Date()) + "-----" + Thread.currentThread().getName()+"---" + "HeartBeat.........................");
            }
        }, 5, 3, TimeUnit.SECONDS);   //5秒后第一次执行，之后每隔3秒执行一次

    }
}

执行结果：

2020-01-09 16:13:53-----pool-1-thread-1---HeartBeat.........................
2020-01-09 16:13:56-----pool-1-thread-1---HeartBeat.........................
2020-01-09 16:13:59-----pool-1-thread-2---HeartBeat.........................
2020-01-09 16:14:02-----pool-1-thread-1---HeartBeat.........................
2020-01-09 16:14:05-----pool-1-thread-3---HeartBeat.........................
2020-01-09 16:14:08-----pool-1-thread-3---HeartBeat.........................
2020-01-09 16:14:11-----pool-1-thread-3---HeartBeat.........................
2020-01-09 16:14:14-----pool-1-thread-3---HeartBeat.........................

newSingleThreadExecutor 创建一个单线程化的线程池，它会用唯一的工作线程来执行任务，保证任务按照先进先出的顺序执行。

public class Test {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "   i=" + temp);
                }
            });
        }
    }
}

执行结果

pool-1-thread-1   i=0
pool-1-thread-1   i=1
pool-1-thread-1   i=2
pool-1-thread-1   i=3
pool-1-thread-1   i=4
pool-1-thread-1   i=5
pool-1-thread-1   i=6
pool-1-thread-1   i=7
pool-1-thread-1   i=8
pool-1-thread-1   i=9

 

ThreadPoolExecutor的中的submit和FutureTask || 通过Executors 创建线程池的一些实例（Callable和Runnable的在其中的体现）
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
02-22 4339
线程的创建方式，Callable接口和Future接口的配合，Runnable任务、Callable任务提交到线程池，他们之间的区别
Java多线程：submit()和execute()到底怎么选？一个真实业务场景帮你彻底搞懂
最新发布
weixin_42533622的博客
05-01 366
本文深入探讨Java多线程编程中submit()和execute()方法的本质区别与适用场景，通过真实图片处理案例解析两者的异常处理、任务控制和资源管理特性。针对ExecutorService的核心方法，提供从简单日志记录到复杂图片处理的完整决策框架，帮助开发者根据业务需求选择最佳方案。
JAVA线程池submit详解 ，execute和submit提交任务的区别
胖虎儿的博客
06-21 1万+
JAVA线程池submit详解 ，execute和submit提交任务的区别
ThreadPoolExecutor的submit正确的使用方式
查拉图斯特拉talk的博客
08-04 3866
习惯了用execute就忘记了submit的正确使用方式，惯性是很恐怖的，还是得多多跑跑单元测试。
多线程(二) | 彻底搞懂线程池-Executors
lsqingfeng的博客
04-14 4085
[原文约7000字] 上篇文章，我们讲解了通过Thread和 Runnable 使用线程的方法，并且演示了如何创建一个线程并启动，今天我们来聊一聊多线程中的线程池。 一、为什么要使用线程池 我们使用多线程的一个一般步骤是： 先创建一个线程，然后线程执行线程任务，线程任务执行完毕后，线程会被销毁。 但是线程的创建和销毁是比较耗费资源的。在高并发场景之下，如果需要开启大量的线程，而每个线程它执行任务所需的时间很短的情况下，那么线程的频繁的创建和销毁就会成为性能的瓶颈。所以线程池应运而生。线程池的主要功能
线程池ThreadPoolExecutor的submit方法
ccityzh的博客
01-27 1万+
Future submit(Callable task);     Future submit(Runnable task, T result);     Future submit(Runnable task); 三个重载方法，第一个很好理解，传入callable，本身call函数就有一个返回值，可以正常取得。 第二个第三个就不清楚怎么可以取到返回值了，因为Runnabl
java线程池使用最全详解
热门推荐
qq_40093255的博客
05-18 9万+
线程池使用 前言 在执行一个异步任务或并发任务时，往往是通过直接new Thread()方法来创建新的线程，这样做弊端较多，更好的解决方案是合理地利用线程池，线程池的优势很明显，如下： 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗； 提高系统响应速度，当有任务到达时，无需等待新线程的创建便能立即执行； 方便线程并发数的管控，线程若是无限制的创建，不仅会额外消耗大量系统资源，更是占用过多资源而阻塞系统或oom等状况，从而降低系统的稳定性。线程池能有效管控线程，统一分配、调优，提供资源
Java线程池参数详解
2301_80795057的博客
07-12 2万+
线程池是现代并发编程中不可或缺的工具，合理配置线程池参数能够显著提升应用的性能和稳定性。本文将深入剖析线程池的核心参数，包括核心线程数、最大线程数、线程存活时间、任务队列类型及拒绝策略等，结合实际案例帮助读者理解每个参数的作用及调优思路。
java线程池使用详解ThreadPoolExecutor使用示例
xu_yong_lin的博客
06-03 5万+
一 使用线程池的好处 二 Executor 框架 2.1 简介 2.2 Executor 框架结构(主要由三大部分组成) 1) 任务(Runnable /Callable) 2) 任务的执行(Executor) 3) 异步计算的结果(Future) 2.3 Executor 框架的使用示意图 三 (重要)ThreadPoolExecutor 类简单介绍 3.1 ThreadPoolExecutor 类分析 3.2 推荐使用 ThreadPoolExecutor 构造函数创建线程池 四 ..
Java 线程池原理详解
微笑听雨
06-04 1974
本文全面解析Java线程池的实现原理和使用方法。线程池通过复用线程、控制并发数量、任务队列管理等机制提升系统性能。核心类是ThreadPoolExecutor，包含核心线程数、最大线程数、任务队列等关键参数配置。
Java线程池详解
qq_24574189的博客
07-19 1427
Java线程池详解
ThreadPoolExecutor中的submit()方法详细讲解
Widsom的博客
06-09 8万+
ThreadPoolExecutor中的submit()方法详细讲解在使用线程池的时候，发现除了execute()方法可以执行任务外，还发现有一个方法submit()可以执行任务。submit()有3个参数不一的方法，这些方法都是在ExecutorService接口中声明的，在AbstractExecutorService中实现，而ThreadPoolExecutor继承AbstractExecut
executor.execute()与 executor.submit()区别
qq_31532979的贺公子之数据科学与艺术博客，致力于科技向善，拥抱开源，要用技术的影响力来领导团队，而不是威权和职位！
04-17 3416
方法则适用于需要获取任务结果、进行精细的异常处理、监控任务状态或可能需要取消任务的情况。提供了诸如检查任务是否已完成、阻塞等待任务完成、获取任务结果或取消任务等操作。方法更适合用于提交不需要返回结果、异常处理相对简单且不需要取消功能的任务。接口的任务，这类任务没有返回值，通常用于执行纯粹的操作或计算。方法，允许尝试取消尚未开始或正在进行的任务。：当提交的任务在执行过程中抛出异常时，该异常将被传递给线程的。提交一个任务时，无法直接获取任务执行的结果或状态。，所以无法直接取消已提交的任务或查询其执行状态。
13.ThreadPoolExecutor线程池之submit方法
weixin_33754913的博客
06-17 820
jdk1.7.0_79  　　在上一篇《ThreadPoolExecutor线程池原理及其execute方法》中提到了线程池ThreadPoolExecutor的原理以及它的execute方法。本文解析ThreadPoolExecutor#submit。 　　对于一个任务的执行有时我们不需要它返回结果，但是有我们需要它的返回执行结果。对于线程来讲，如果不需要它返回结果则实现Runnable，而...
Java线程池submit阻塞获取结果实现原理
BASK2311的博客
10-23 2571
Java线程池中提交任务运行，通常使用execute()方法就足够了。那如果想要实现在主线程中阻塞获取线程池任务运行的结果，该怎么办呢？答案是用submit()方法提交任务。这也是面试中经常被问到的一个知识点，execute()和submit()提交任务的的区别是什么？底层是如何实现的？submit()方法中调用方法获取对象。// 调用FutureTask的构造方法返回RunnableFuture对象}复制代码FutureTaskFutureTask是一个异步计算任务，包装了我们外部提交的任务。
Java并发基础(18)：ExecutorService中submit方法详解
mingyuli的博客
04-05 3426
1 submit() submit( )：该方法接收Runnable或Callable对象作为输入参数（该方法输入参数请参考上篇文章java线程池任务提交（Runnable、Callable、FutureTask）， 这篇文章主要讲submit方法的返回值以及返回值的使用），返回一个Future对象。submit方法提交的任务中的call方法如果返回Integer，那么submit方法就返回Future<Integer>；如果call方法返回Float，那么submit方法就返回Future&
Python网络与并发编程 15 使用执行器提交任务
weixin_43422005的博客
07-12 1739
concurrent.futures 我们在以往创建线程或进程的时候都会使用threading与multiprocessing模块进行创建。 那么在本章节学习完成后就不要使用这两种方式创建线程或者进程了，而是应当使用concurrent.futures所提供的执行器来构建线程或进程并执行任务。 concurrent.futures提供了2种执行器，如下所示，它们的接口使用也都一模一样： from concurrent.futures import ThreadPoolExecutor # 线程池执行器 f
Python从小白到高手实现系列二百二十一：有用的设计模式
Mr_Roki的博客
03-24 425
本书是这个领域中的重要著作，它收录了23 种设计模式，并使用SmallTalk 和C++编写了示例。更安全的方式是使用更先进的技术—元类（metaclasses）。除了工厂设计模式，在Python 中，GoF 中唯一值得注意的其他创建型设计模式是单例。要单例，为什么不使用带有函数的模块，因为Python 模块已经是单例了？这些是编译型语言（如C 或C ++）中非常重要的模式，因为在运行时难以生成需要的类型。本章介绍了Python 中最有用的以及最值得大家讨论的模式，以及实现示例。用程序通常被声明为单例。
线程池excutor submit 两种方式 对于异常的处理问题的探究
qq_44716086的博客
02-24 1870
不知大家在对待excutor or sumbit方式执行的线程池，内部出现异常是否要catch住这个问题有没有思考？ 例如，我常在代码中发现以下处理方式：
线程池全面解析
haovin的博客
06-28 581
0、目录 一、介绍 二、工作原理 三、使用 四、Java中自动的四种线程池 五、Future和FutureTask 六、总结 一、介绍 二、工作原理 首先介绍线程池的类图： ThreadPoolExecutor类是线程池的真正实现类，可以根据不同的需求配置相关的参数，从而实现自定义线程池。（一般不需要自定义线程池，Java内部已经实现了四个常用的线程池，且都已经配...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值