ThreadPoolExecutor线程池详解

已于 2024-10-07 14:02:40 修改
阅读量514 收藏
点赞数
文章标签： java 线程池
于 2023-08-08 17:17:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y_eatMeat/article/details/132171516
版权

ThreadPoolExecutor线程池详解

1. 背景

项目最近的迭代中使用到了ThreadPoolExecutor线程池，之前都只是知道怎么用，没有了解过线程池的底层原理，项目刚上线，有时间整理一下线程池的用法，学习一下线程池的底层实现与工作原理。

2. ThreadPoolExecutor工作原理

2.1 构造方法

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;
    }

2.2 线程池的使用

  • worker
/**
 * @author itender
 * @date 2023/8/7 14:41
 * @desc
 */
public class Worker implements Runnable {

    private String command;

    public Worker(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + command + " startTie = " + DateUtil.now());
        processCommand();
        System.out.println(Thread.currentThread().getName() + command +  " endTime = " + DateUtil.now());
    }

    private void processCommand() {
        try {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + command +" 处理任务逻辑。。。。。。。。");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return this.command;
    }
}
  • 线程池
/**
 * @author itender
 * @date 2023/8/7 14:37
 * @desc
 */
public class ThreadPoolExecutorDemo {
    private static final int CORE_POOL_SIZE = 5;
    private static final int MAX_POOL_SIZE = 10;
    private static final int QUEUE_CAPACITY = 100;
    private static final Long KEEP_ALIVE_TIME = 1L;
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                // 核心线程数 5
                CORE_POOL_SIZE,
                // 最大线程数 10
                MAX_POOL_SIZE,
                // 超过核心线程数，线程最大存活时间
                KEEP_ALIVE_TIME,
                // 时间单位
                TimeUnit.MINUTES,
                // 工作队列最大值
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
            	// 线程工厂，创建线程的时候使用
                r -> {
                    Thread thread = new Thread(r);
                    thread.setName("pool-");
                    return thread;
                },
        new ThreadPoolExecutor.CallerRunsPolicy()
        );
        for (int i = 0; i < 10; i++) {
            // 创建任务
            Worker myRunnable = new Worker("" + i);
            // 执行任务
            threadPoolExecutor.execute(myRunnable);
        }
        // 种植线程池，不接受新任务，但是有工作线程处理队列中的任务
        threadPoolExecutor.shutdown();

        while (!threadPoolExecutor.isTerminated()) {

        }
        System.out.println("Finished All Threads!");
    }
}

2.3 核心参数

2.3.1 核心参数详解
  • corePoolSize：核心线程数，任务队列没有达到队列最大容量时，最大可以同时运行的线程数。
  • maximumPoolSize：最大线程数。当任务队列中存储的任务达到队列的容量时，当前可以同时运行的线程数量变为最大线程数。
  • keepAliveTime：线程池中的线程数量超过corePoolSize时，如果没有新任务提交，核心线程外的线程不会立即销毁，而是等待，直到等待的时间超过了keepAliveTime才会被销毁回收。
  • unit：keepAliveTime参数的时间单位。
  • workQueue：工作队列。当有新的任务提交的时候，会先判断当前运行的线程数是否达到核心线程数，如果达到核心线程数，则会把新提交的任务放到工作队列中。
  • threadFactory：线程工厂，创建新的线程时会使用。
  • handler：拒绝策略。
2.3.2 拒绝策略

如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任务时，ThreadPoolTaskExecutor 定义一些策略:

  • AbortPolicy：默认拒绝策略。抛出RejectExecutionException来拒绝新任务的处理。
  • CallerRunsPolicy：调用当前提交任务的线程来执行任务。一般不希望任务丢失会选用这种策略，但从实际角度来看，原来的异步调用意图会退化为同步调用。
  • DiscardPolicy：不处理新任务，直接丢弃。
  • DiscardOldestPolicy：丢弃最早的未处理的任务。

2.4 执行流程

在这里插入图片描述

2.5 线程池状态

2.5.1 线程池核心属性ctl
	// ctl本质是 Integer 型变量，进行了原子性的封装
	// ctl表示两种状态：
	// 高3位：线程池当前的状态
	// 低29位：线程池当前工作线程的数量
	private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
	// COUNT_BITS 的值为 29（整型Integer.SIZE = 32 位）;
    private static final int COUNT_BITS = Integer.SIZE - 3;
	// CAPACITY = (1 << 29) - 1; 1左移29位，减去1；即1*2^29-1；
	// 0001 1111 1111 1111 1111 1111 1111 1111
	// 低29位用来表示线程池的最大线程容量
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
	
	// 高3位用来表示线程池5种状态
	// 111 运行状态
    private static final int RUNNING    = -1 << COUNT_BITS;
	// 000 shutdown状态
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
	// 001 停止状态
    private static final int STOP       =  1 << COUNT_BITS;
	// 010 过渡状态
    private static final int TIDYING    =  2 << COUNT_BITS;
	// 011 中介状态
    private static final int TERMINATED =  3 << COUNT_BITS;
	// 根据ctl的值，计算当前线程池的状态
	// 计算方式：c 与 非capacity
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
	// 根据ctl的值，计算线程池当前运行的线程的容量
    private static int workerCountOf(int c)  { return c & CAPACITY; }
	// 通过运行状态和工作线程数计算ctl的值，或运算
    private static int ctlOf(int rs, int wc) { return rs | wc; }

    private static boolean runStateLessThan(int c, int s) {
        return c < s;
    
    private static boolean runStateAtLeast(int c, int s) {
        return c >= s;
    }
    
    private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }

    /**
     * Attempts to CAS-increment the workerCount field of ctl.
     */
    private boolean compareAndIncrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect + 1);
    }

    /**
     * Attempts to CAS-decrement the workerCount field of ctl.
     */
    private boolean compareAndDecrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect - 1);
    }

    /**
     * Decrements the workerCount field of ctl. This is called only on
     * abrupt termination of a thread (see processWorkerExit). Other
     * decrements are performed within getTask.
     */
    private void decrementWorkerCount() {
        do {} while (! compareAndDecrementWorkerCount(ctl.get()));
    }
2.5.2 状态切换

在这里插入图片描述

  • RUNNING ：能接受新提交的任务，并且也能处理阻塞队列中的任务。
  • SHUTDOWN：关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务。在线程池处于 RUNNING 状态时，调用 shutdown() 方法会使线程池进入到该状态。（finalize() 方法在执行过程中也会调用 shutdown() 方法进入该状态）。
  • STOP：不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。在线程池处于 RUNNING 或 SHUTDOWN 状态时，调用 shutdownNow() 方法会使线程池进入到该状态。
  • TIDYING：如果所有的任务都已终止了，workerCount (有效线程数) 为0，线程池进入该状态后会调用 terminated() 方法进入 TERMINATED 状态。
  • TERMINATED：在terminated()方法执行完后进入该状态，默认 terminated() 方法中什么也没有做。

3. 源码分析

3.1 execute方法

  • 源码
public void execute(Runnable command) {
    	// 判断任务是否为空,如果任务为空，抛出空指针异常
        if (command == null)
            throw new NullPointerException();
    	// 获取ctl属性
        int c = ctl.get();
    	// 判断当前工作线程数量是否小于核心线程的数量
        if (workerCountOf(c) < corePoolSize) {
            // 工作线程数小于核心线程数，创建一个核心线程执行command任务
            if (addWorker(command, true))
                // 创建核心线程成功，直接返回
                return;
            // 并发情况下添加核心线程失败，需要重新获取ctl属性
            c = ctl.get();
        }
    	// 创建核心线程失败，当前工作线程数量大于或等于核心线程数量corePoolSize
    	// 判断线程池的状态是否为running，如果是添加任务到工作队列中（放入任务失败返回false）
        if (isRunning(c) && workQueue.offer(command)) {
            // 任务添加到队列成功，再次获取ctl属性
            int recheck = ctl.get();
            // 二次检查，判断线程池的状态是否为running，如果不是队列中移除刚刚添加的任务
            if (!isRunning(recheck) && remove(command))
                // 执行拒绝策略
                reject(command);
            // 1.任务添加到队列
            // 2.线程池可能是running状态
            // 3.传入的任务可能从任务队列中移除失败（移除失败的唯一可能就是任务已经被执行了）
            // 判断工作线程数量是否为0
            else if (workerCountOf(recheck) == 0)
                // 工作线程数量为0
                // 工作队列中有任务在排队，添加一个空任务，创建非核心线程执行队列中等待的任务
                addWorker(null, false);
        }
    	// 创建核心线程失败，
    	// 线程池状态不是running状态
    	// 线程池可能是running状态，但是任务队列已经满了
    	// 添加任务到工作队列失败，创建非核心线程执行任务
        else if (!addWorker(command, false))
            // 创建非核心线程失败，执行拒绝策略
            reject(command);
    }

第一点核心：通过execute方法源码可以看出线程池具体的执行流程，以及一些避免并发情况的判断。

第二点核心：线程池为什么会添加空任务非核心线程到线程池。

这里是一个疑惑点：为什么需要二次检查线程池的运行状态，当前工作线程数量为0，尝试创建一个非核心线程并且传入的任务对象为null？这个可以看API注释：

如果一个任务成功加入任务队列，我们依然需要二次检查是否需要添加一个工作线程（因为所有存活的工作线程有可能在最后一次检查之后已经终结）或者执行当前方法的时候线程池是否已经shutdown了。所以我们需要二次检查线程池的状态，必须时把任务从任务队列中移除或者在没有可用的工作线程的前提下新建一个工作线程。

3.2 addWorker方法

  • 源码
private boolean addWorker(Runnable firstTask, boolean core) {
    // for循环标识
    // 对线程池当前状态和当前工作线程数量的判断
    retry:
    for (;;) {
        // 获取线程池的状态
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

        for (;;) {
            // 获取线程池工作线程的数量
            int wc = workerCountOf(c);
             // 1. 如果传入的core为true，表示将要创建核心线程，通过wc和corePoolSize判断，如果wc >= corePoolSize，则返回false表示创建核心线程失败
            // 2. 如果传入的core为false，表示将要创非建核心线程，通过wc和maximumPoolSize判断，如果wc >= maximumPoolSize，则返回false表示创建非核心线程失败
            // core参数为false说明工作队列已经满了，线程池大小变为maximumPoolSize最大线程数
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            // CAS更新工作线程数wc，原子操作将workCount的数量加1，更新成功则直接跳出最外层循环
            if (compareAndIncrementWorkerCount(c))
                break retry;
            // CAS更新工作线程数失败，判断线程池的状态是否从running编程shutdown，如果线程池的状态改变了在执行上面的操作
            c = ctl.get();  // Re-read ctl
            // 如果线程池状态已经变成shutdown，跳过最外层本次循环，执行下一次循环
            if (runStateOf(c) != rs)
                continue retry;
            // 如果线程池状态依然是RUNNING，CAS更新工作线程数wc失败说明有可能是并发更新导致的失败，则在内层循环重试即可 
            // else CAS failed due to workerCount change; retry inner loop
        }
    }
	// 工作线程是否启动成功
    boolean workerStarted = false;
    // 工作线程是否创建成功
    boolean workerAdded = false;
    Worker w = null;
    try {
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            // 加锁，因为会改变一些指标值和非线程安全的集合
            final ReentrantLock mainLock = this.mainLock;
            // 加锁
            mainLock.lock();
            try {
                // 获取线程池状态
                int rs = runStateOf(ctl.get());
				//rs < SHUTDOWN 如果线程池状态依然为RUNNING,并且线程的状态是存活的话，就会将工作线程添加到工作线程集合中
        		//(rs=SHUTDOWN && firstTask == null)如果线程池状态小于STOP，也就是RUNNING或者SHUTDOWN状态下，同时传入的任务实例firstTask为null，则需要添加到工作线程集合和启动新的Worker
                // 对于2，换言之，如果线程池处于SHUTDOWN状态下，同时传入的任务实例firstTask不为null，则不会添加到工作线程集合和启动新的Worker
                // 这一步其实有可能创建了新的Worker实例但是并不启动（临时对象，没有任何强引用），这种Worker有可能成功下一轮GC被收集的垃圾对象
        		// firstTask == null证明只新建线程而不执行任务
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    // 将新建的工作线程添加到工作线程的集合
                    workers.add(w);
                    // 更新当前工作线程的最大容量
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    // 工作线程是否添加成功
                    workerAdded = true;
                }
            } finally {
                // 释放锁
                mainLock.unlock();
            }
            // 如果成功添加工作线程，则调用Worker内部的线程实例t的Thread#start()方法启动真实的线程实例
            if (workerAdded) {
                // 启动线程，标识线程启动成功
                t.start();
                workerStarted = true;
            }
        }
    } finally {
         // 线程启动失败，需要从工作线程中移除对应的Worker
        if (!workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

4. 线程池常见问题

4.1 execute() 和submit()的区别

  • execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；
  • submit()方法用于提交需要返回值的任务。线程池会返回一个 Future 类型的对象，通过这个 Future 对象可以判断任务是否执行成功，并且可以通过 Future 的 get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用 get（long timeout，TimeUnit unit）方法的话，如果在 timeout 时间内任务还没有执行完，就会抛出 java.util.concurrent.TimeoutException。

4.3 阻塞队列的作用

  • 一般的队列只能是有限长度的缓冲区，一旦超出缓冲长度，就无法保留了。阻塞队列通过阻塞可以保留住当前想要继续入队的任务。

  • 阻塞队列可以在队列中没有任务时，阻塞想要获取任务的线程，使其进入wait状态，释放cpu资源。

  • 阻塞队列带有阻塞和唤醒的功能，不需要额外处理，无任务执行时，线程池利用阻塞队列的take方法挂起，从而维持核心线程的存活，不至于一直占用cpu资源。

4.2 为什么先添加队列而不是先创建最大线程

  • 在创建新线程的时候，是要获取全局锁的，这时候其他线程会被阻塞，影响整体效率。

  • 在核心线程已满时，如果任务继续增加那么放在队列中，等队列满了而任务还在增加那么就要创建临时线程了，这样代价低。

5. 参考文章

https://www.throwx.cn/2020/08/23/java-concurrency-thread-pool-executor/

https://javaguide.cn/java/concurrent/java-thread-pool-summary.html#%E7%BA%BF%E7%A8%8B%E6%B1%A0%E5%8E%9F%E7%90%86%E5%88%86%E6%9E%90

YAnalytics
关注
Java中创建线程的方式以及线程池创建的方式、推荐使用ThreadPoolExecutor以及示例
BADAO_LIUMANG_QIZHI的博客
04-10 2136
Java中创建线程的方式有三种1、通过继承Thread类来创建线程定义一个线程类使其继承Thread类，并重写其中的run方法，run方法内部就是线程要完成的任务，因此run方法也被称为执行体，使用start方法来启动线程。2、通过实现Runanle接口来创建线程首先定义Runnable接口，并重写Runnable接口的run方法，run方法的方法体同样是该线程的线程执行体。3、通过Callable 和 Future来创建线程。
ThreadPoolExecutor 线程池详解
瞎叨叨的一天的博客
07-09 551
ThreadPoolExecutor 线程池详解
ThreadPoolTaskExecutor 详解
zhujyy110的专栏
08-28 6604
是 Java 线程池的一个重要接口，用于定义当线程池已满并且无法接受新任务时，如何处理被拒绝的任务。当线程池的队列和线程都已满，新任务就会被拒绝执行，这时就会使用。线程池在多线程编程中非常有用，因为它可以管理线程的生命周期、避免不必要的线程创建和销毁开销，以及控制并发线程的数量，从而提高程序的性能和资源利用率。你可以根据实际需求进行调整。是 Spring 框架提供的一个非常方便的线程池实现，适用于在 Spring 应用程序中进行多线程任务的管理和执行。线程池中的线程可以被复用，从而减少线程创建的开销。
13、线程池ThreadPoolExecutor实战及其原理分析
最新发布
weixin_43164559的博客
09-25 943
线程池（Thread Pool）是一种基于池化思想管理线程的工具，经常出现在多线程服务器中，如Tomcat。线程过多会带来额外的开销，其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。：通过池化技术重复利用已创建的线程，降低线程创建和销毁造成的损耗。：任务到达时，无需等待线程创建即可立即执行。
ThreadPoolTaskExecutor创建线程池
Demon_Hao的博客
10-16 402
线程池是一种利用池化技术思想来实现的线程管理技术，主要是为了复用线程、便利地管理线程和任务、并将线程的创建和任务的执行解耦开来。我们可以创建线程池来复用已经创建的线程来降低频繁创建和销毁线程所带来的资源消耗。2、方法上添加@Async("threadPoolTaskExecutor")注解实现异步操作（常见失效原因：不是public方法、返回不是void或者Future、使用static修饰）3、个人建议不要使用SpringBoot默认线程池，可能会造成OOM。
ThreadPoolTaskExecutor 创建线程池管理
Wangfeifdfdfdgrgfvbb的专栏
07-29 1126
class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">            corePoolSize:默认开启线程数；maxPoolSize：最大线程数；queueCapacity：缓冲任务队列的长度； threadPool.execute(new Runnable() { public
线程池ThreadPoolTaskExecutor实战
雨剑的博客
11-27 1万+
文章目录1. ThreadPoolTaskExecutor是什么2. 为什么使用ThreadPoolTaskExecutor2.1直接使用ThreadPoolExecutor2.2 使用ThreadPoolTaskExecutor3. 如何使用ThreadPoolTaskExecutor3.1 配置3.2 业务中使用3.3 TaskDecorator 1. ThreadPoolTaskExecutor是什么 ThreadPoolTaskExecutor是Spring基于java本身的线程池ThreadPoo
ThreadPoolExecutor创建线程池详解
weixin_41987908的博客
06-02 1170
该接口是真正的线程池接口。上面的ThreadPoolExecutor以及下面的都是该接口的实现类。Future submit(Runnable task)：提交Runnable任务到线程池，返回Future对象，由于Runnable没有返回值，也就是说调用Future对象get()方法返回null。Future submit(Callable task)：提交Callable任务到线程池，返回Future对象，调用Future对象get()方法可以获取Callable的返回值。
ThreadPoolExecutor线程池原理及其execute方法(详解)
08-30
ThreadPoolExecutor线程池原理及其execute方法详解 ThreadPoolExecutor是Java并发包中提供的线程池类，用于管理和执行异步任务。ThreadPoolExecutor的执行原理可以分为四个步骤： 1.核心线程池：...
简单谈谈ThreadPoolExecutor线程池之submit方法
08-30
"ThreadPoolExecutor线程池之submit方法详解" 在 Java 中，ThreadPoolExecutor 是一个非常重要的线程池实现类，它提供了多种方式来执行任务，其中 submit 方法是其中一个重要的方法，本文将详细解释 ...
死磕ThreadPoolExecutor线程池.pdf
07-27
死磕ThreadPoolExecutor线程池.pdf！！死磕ThreadPoolExecutor线程池.pdf死磕ThreadPoolExecutor线程池.pdf死磕ThreadPoolExecutor线程池.pdf
ThreadPoolTaskExecutor线程池创建
weixin_37799575的博客
08-22 1052
【代码】ThreadPoolTaskExecutor线程池创建。
Spring ThreadPoolTaskExecutor 创建线程池管理
wanxiaotao12-126-com
01-05 96
http://www.blogjava.net/lukangping/articles/332806.html   http://blog.csdn.net/seminmredoxu/article/details/7000709   http://blog.csdn.net/sfdev/article/details/4056114
创建一个线程池，使用ThreadPoolTaskExecutor类
qq_19891197的博客
04-13 520
创建一个线程池，使用ThreadPoolTaskExecutor类
【JUC源码】线程池：ThreadPoolExecutor 万字源码深析（超详细注释）
热门推荐
A minor
10-03 2万+
ThreadPoolExecutor 的类注释有很多，选取关键的注释如下： ExecutorService 使用线程池中的线程执行提交的任务，线程池我们可以使用 Executors 进行配置； 线程池解决两个问题：1：通过减少任务间的调度开销 (主要是通过线程池中的线程被重复使用的方式)，来提高大量任务时的执行性能；2：提供了一种方式来管理线程和消费，维护基本数据统计等工作，比如统计已完成的任务数； Executors 为常用的场景设定了可直接初始化线程池的方法，比如 Executors#newCache
Spring自带的线程池ThreadPoolTaskExecutor
wejack的专栏
03-16 732
文章系转载，方便整理和归纳，源文地址：https://zhuanlan.zhihu.com/p/346086161 前言 上一篇分享了JDK自带的线程池ThreadPoolExecutor的配置和参数详解，然而我们实际开发中更多的是使用SpringBoot来开发，Spring默认也是自带了一个线程池方便我们开发，它就是ThreadPoolTaskExecutor，接下来我们就来聊聊Spring的线程池吧。 Spring默认线程池simpleAsyncTaskExecutor Spring异步线程池的接口.
线程池ThreadPoolExecutor详解（整理详细）
trusause的博客
07-12 2万+
线程池
JAVA多线程之ThreadPoolExecutor创建线程池
lqr666的博客
01-12 3272
线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。说明：Executors 返回的线程池对象的弊端如下：FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。
Spring(19) ThreadPoolTaskExecutor 线程池的使用
ACGkaka的博客
01-18 2382
Spring(19) ThreadPoolTaskExecutor 线程池的使用
threadpoolexecutor线程池
08-23
ThreadPoolExecutor线程池提供了更灵活的线程管理和任务调度的功能，并且可以根据需要进行配置。可以通过指定核心线程数、最大线程数、线程存活时间和任务队列等参数来创建和配置ThreadPoolExecutor线程池。 使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值