为什么不推荐使用JDK自带的线程池

package com.daxiong;

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

/**
 * <p>JDK内置线程池的底层阻塞队列</p>
 *
 * @author xuexionghui
 * @describe
 * @date 2023/2/21 17:39
 */
public class Test6 {
    public static void main(String[] args) {
        // 创建一个可缓存的线程池 阻塞队列是SynchronousQueue，不存储元素，最大线程数是Integer的最大值，会不断创建线程，
        // 不会走拒绝策略，直到内存溢出
        //    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
        //                                      60L, TimeUnit.SECONDS,
        //                                      new SynchronousQueue<Runnable>());
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        // 创建一个固定线程数的线程池 阻塞队列是LinkedBlockingQueue，LinkedBlockingQueued的默认容量是Integer的最大值，相当于无界，
        // 这样有任务到来的时候，会把任务塞到阻塞队列中，不会走拒绝策略，直到内存溢出
        // return new ThreadPoolExecutor(nThreads, nThreads,
        //                                      0L, TimeUnit.MILLISECONDS,
        //                                      new LinkedBlockingQueue<Runnable>());
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

        // 创建一个工作线程的线程池，阻塞队列是LinkedBlockingQueue,LinkedBlockingQueue的容量默认是Integer的最大值，相当于无界
        // 这样有任务到来的时候，会把任务塞到阻塞队列中，不会走拒绝策略，直到内存溢出
        //         return new FinalizableDelegatedExecutorService
        //            (new ThreadPoolExecutor(1, 1,
        //                                    0L, TimeUnit.MILLISECONDS,
        //                                    new LinkedBlockingQueue<Runnable>()));
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

        // 创建一个可定时执行的线程池,阻塞队列是DelayedWorkQueue，最大线程是Integer的最大值，所以有任务来的时候，会一直创建线程，根本不会走
        // 线程的拒绝策略，直到内存溢出
        //         super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
        //              new DelayedWorkQueue());
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(1);
    }
}