Insufficient executors to build thread pool

One summary

When building a thread pool, we can simply use Executors To build , With newFixedThreadPool For example ：

public static ExecutorService executor = Executors.newFixedThreadPool(10);

Two Executors Shortcomings of building threads

Thread pools are not allowed Executors To create , But through ThreadPoolExecutor The way , This processing method makes the developer more clear about the running rules of the thread pool , Avoid the risk of resource depletion . explain ：Executors The disadvantages of the returned thread pool object are as follows ：
1）FixedThreadPool and SingleThreadPool:
   The allowed request queue length is Integer.MAX_VALUE, A large number of requests may pile up , Which leads to OOM.
2）CachedThreadPool:
   The number of threads allowed to be created is Integer.MAX_VALUE, A large number of threads may be created , Which leads to OOM.

        Suggested Java How it was created

Positive example 1：
    //org.apache.commons.lang3.concurrent.BasicThreadFactory
    ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
        new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
       
        
            
Positive example 2：
    ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
        .setNameFormat("demo-pool-%d").build();

    //Common Thread Pool
    ExecutorService pool = new ThreadPoolExecutor(5, 200,
        0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    pool.execute(()-> System.out.println(Thread.currentThread().getName()));
    pool.shutdown();//gracefully shutdown

        Suggested XML How it was created

Positive example 3：
    <bean id="userThreadPool"
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <property name="corePoolSize" value="10" />
        <property name="maxPoolSize" value="100" />
        <property name="queueCapacity" value="2000" />

    <property name="threadFactory" value= threadFactory />
        <property name="rejectedExecutionHandler">
            <ref local="rejectedExecutionHandler" />
        </property>
    </bean>
    //in code
    userThreadPool.execute(thread);

3、 ... and People often build thread pools

public class ThreadPool {

    /**
     *  Thread pool executor 
     */
    private static ThreadPoolTaskExecutor EXECUTOR = new ThreadPoolTaskExecutor();

    static {
        // Number of core threads 
        EXECUTOR.setCorePoolSize(10);
        // Maximum number of threads 
        EXECUTOR.setMaxPoolSize(20);
        // Queue size 
        EXECUTOR.setQueueCapacity(200);
        // Maximum number of threads  -  Number of core threads   Idle survival time 
        EXECUTOR.setKeepAliveSeconds(60);
        // The thread name prefix in the thread 
        EXECUTOR.setThreadNamePrefix("common-pool-");
        // Rejection policy for thread pool 
        EXECUTOR.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // Initialization of thread pool 
        EXECUTOR.initialize();
    }

    /**
     *  Get thread pool 
     * @param
     */
    public static ThreadPoolTaskExecutor getExecutor() {
        return EXECUTOR;
    }

    /**
     *  perform 
     * @param command
     */
    public static void execute(Runnable command) {
        EXECUTOR.execute(command);
    }
}