What are the four thread pools that come with Java?

What are the four predefined thread pools in java?

• newSingleThreadExexcutor: Thread pool with a single number of threads (number of core threads = maximum number of threads = 1)

• newFixedThreadPool: Fixed number of threads Pool (number of core threads = maximum number of threads = custom)

• newCacheThreadPool: Cacheable thread pool (number of core threads = 0, maximum number of threads = Integer.MAX_VALUE)

• newScheduledThreadPool: Thread pool that supports scheduled or periodic tasks (number of core threads = custom, maximum number of threads = Integer.MAX_VALUE)

Four kinds of threads What's the difference between pools?

The above four thread pool classes all inherit ThreadPoolExecutor and directly return new ThreadPoolExecutor (parameters) when created. The difference between them is that the parameters in the defined ThreadPoolExecutor (parameters) are different, and ThreadPoolExecutor inherits the ExecutorService interface class.

• newFixedThreadPool

Definition:
xecutorService executorService=Executors.newFixedThreadPool(2);

Disadvantages: LinkBlockQueue's linked list blocking queue is used. When the accumulation speed of tasks is greater than the processing speed, it is easy to accumulate tasks and cause OOM memory overflow

• newSingleThreadExecutor

##Definition: ExecutorService executorService =Executors.newSingleThreadExecutor();

The above code is similar new FixedThreadPoop(1), but there is a difference, because there is an extra layer of FinalizableDelegatedExecutorService, its function:

It can be seen that the essence of fixedExecutorService is ThreadPoolExecutor, so fixedExecutorService can be forced to transfer into ThreadPoolExecutor, but singleExecutorService has nothing to do with ThreadPoolExecutor, so the forced transfer fails. Therefore, after newSingleThreadExecutor() is created, its thread pool parameters cannot be modified, and it is truly a single thread.

Disadvantages: LinkBlockQueue's linked list blocking queue is used. When the accumulation speed of tasks is greater than the processing speed, it is easy to accumulate tasks and cause OOM memory overflow

newCacheThreadPool

Definition: ExecutorService executorService=Executors.newCacheThreadPool();

Disadvantages: SynchronousQueue is an implementation of BlockingQueue, it is also a queue, because the maximum number of threads is Integer.MAX_VALUE, so when there are too many threads, it is easy to OOM memory overflow

ScheduledThreadPool

Definition: ExecutorService executorService=Executors.newScheduledThreadPool(2);

源码：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        //ScheduledThreadPoolExecutor继承ThreadPoolExecutor
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    
public ScheduledThreadPoolExecutor(int corePoolSize) {
    //ScheduledThreadPoolExecutor继承ThreadPoolExecutor，故super()会调用ThreadPoolExecutor的构造函数初始化并返回一个ThreadPoolExecutor，而ThreadPoolExecutor使实现ExecutorService接口的
    //最终ScheduledThreadPoolExecutor也和上面几种线程池一样返回的是ExecutorService接口的实现类ThreadPoolExecutor
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

What are the important parameters of the thread pool?

ThreadPoolExecutor construction method is as follows:

##keepAliveTime refers to the current number of threads located in [core Number of threads, maximum number of threads] How long do these non-core threads wait for idle time without any work before exiting the thread pool;
The size of the waiting list and the maximum number of threads It has nothing to do with it. Thread creation priority = core thread> blocking queue> thread expansion (threads can be expanded only when the current number of core threads is less than the maximum number of threads)
If the core The number of threads is 5, the waiting queue length is 3, and the maximum number of threads is 10: When the number of threads continues to increase, 5 core threads are created first. When the number of core threads is full, the threads are thrown into the waiting queue. When the waiting queue is full (3 threads), the maximum number of threads will be compared at this time (you can only appear after waiting for the maximum number of threads to be filled), and you can continue to create 2 threads (5 3 2). If the number of threads exceeds the maximum number of threads, the execution will be rejected. Strategy;
If the number of core threads is 5, the waiting queue length is 3, and the maximum number of threads is 7: When the number of threads continues to increase, create 5 core threads first, and the number of core threads is full. Then throw the thread into the waiting queue. When there are 2 threads in the waiting queue, the maximum number of threads is reached (5 2 = 7), but the waiting queue is not full yet, so you don’t need to worry about the maximum number of threads until the waiting queue is full. (3 blocked threads), the maximum number of threads will be compared at this time (only the maximum number of threads waiting for the queue to be lost can exit), at this time the core is waiting for the queue to be lost = 5 3 = 8>7 = the maximum number of threads, that is, it has been reached If the maximum number of threads is reached, the rejection policy will be implemented;
If the waiting queue is set to LinkedBlockingQueue unbounded queue, this queue is infinite, and it will never reach the maximum judgment value. What about the number of threads?

如何自定义线程池

可以使用有界队列，自定义线程创建工厂ThreadFactory和拒绝策略handler来自定义线程池

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException, IOException {
        int corePoolSize = 2;
        int maximumPoolSize = 4;
        long keepAliveTime = 10;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);
        ThreadFactory threadFactory = new NameTreadFactory();
        RejectedExecutionHandler handler = new MyIgnorePolicy();
       ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit,
                workQueue, threadFactory, handler);
        executor.prestartAllCoreThreads(); // 预启动所有核心线程        
        for (int i = 1; i <= 10; i++) {
            MyTask task = new MyTask(String.valueOf(i));
            executor.execute(task);
        }
        System.in.read(); //阻塞主线程
    }
    static class NameTreadFactory implements ThreadFactory {
        private final AtomicInteger mThreadNum = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + " has been created");
            return t;
        }
    }

    public static class MyIgnorePolicy implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            doLog(r, e);
        }
        private void doLog(Runnable r, ThreadPoolExecutor e) {
            // 可做日志记录等
            System.err.println( r.toString() + " rejected");
//          System.out.println("completedTaskCount: " + e.getCompletedTaskCount());
        }
    }

    static class MyTask implements Runnable {
        private String name;
        public MyTask(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            try {
                System.out.println(this.toString() + " is running!");
                Thread.sleep(3000); //让任务执行慢点
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public String getName() {
            return name;
        }
        @Override
        public String toString() {
            return "MyTask [name=" + name + "]";
        }
    }
}

运行结果：

其中7-10号线程被拒绝策略拒绝了，1、2号线程执行完后，3、6号线程进入核心线程池执行，此时4、5号线程在任务队列等待执行，3、6线程执行完再通知4、5线程执行

The above is the detailed content of What are the four thread pools that come with Java?. For more information, please follow other related articles on the PHP Chinese website!