How to use thread pool correctly



1. jdk creates thread pool

Executors Tool Class itself provides us with several ways to create threads



 public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());

The number of core threads is 0,

The maximum number of threads is MAX_VALUE = 0x7fffffff.

60L: Represents the longest time a thread can survive when the current number of threads in the thread pool is larger than the number of core threads, when no new tasks come in from the queue

TimeUnit.SECONDS: Time in seconds, or 60 seconds

New SynchronousQueue <Runnable>(): Task bounded queue, suitable for scenarios with fewer elements, suitable for data exchange




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

The number of threads in the custom thread pool, the number of core threads and the maximum number of threads are the same.

The number of core threads is created when the thread pool is initialized, so there is no need to create new threads because there are too many tasks, nor to destroy redundant threads, so the waiting time is set to 0L.

New LinkedBlockingQueue <Runnable>(): Bounded blocking queues, underlying linked list implementation, adding and deleting elements using not the same lock.

public LinkedBlockingQueue() {

     * Creates a {@code LinkedBlockingQueue} with the given (fixed) capacity.
     * @param capacity the capacity of this queue
     * @throws IllegalArgumentException if {@code capacity} is not greater
     *         than zero
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);

But in the jdk source code, when we do not pass in capacity, the default queue size is MAX_VALUE = 0x7fffffff, which is equivalent to an unbounded queue.



 public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());

Called is the method of the parent class, continue to look at the concrete implementation of the parent class.

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

Continue to catch up with this method.

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 :
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;

In fact, this method is to make a judgment on the parameters, and then assign them to the member variables. What we want to see is the previous block of code, what is the value passed in?

The maximum number of threads is MAX_VALUE = 0x7fffffff.

The idle waiting time of redundant threads is 0.

new Delayed Queue () Delayed queue, unbounded queue,



public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),

The number of core threads and the maximum number of threads in this thread pool are 1:



2. A summary of jdk's own thread pool creation


Thread pool Number of core threads Maximum number of threads Task queue
newCachedThreadPool() 0 Intger.MAX_VALUE SynchronousQueue < Runnable >() (bounded)
newFixedThreadPool(nThreads) User-defined User-defined Linked BlockingQueue < Runnable >() (unbounded)
newScheduledThreadPool(corePoolSize) User-defined Intger.MAX_VALUE DelayedQueue() (bounded)
newSingleThreadExecutor(threadFactory) 1 1 Linked BlockingQueue < Runnable >() (unbounded)







1. Defects

What are the drawbacks of the thread pools created above?

First of all, the maximum number of threads in the thread pool must not be MAX_VALUE, because our cpu is limited, so when the number of threads reaches the upper limit, continue to create threads, which will inevitably affect the server.

Then, there are several uses of unbounded queues, unbounded queues, which means that when we have enough tasks, we will always store them in this queue. When the storage limit exceeds the memory capacity, it will inevitably cause memory overflow.

These risks cannot be ignored in production, so we need to define thread pools ourselves.



3. Custom thread pool

Post code first

public static void main(String[] args) {
		ThreadPoolExecutor threadPool=new ThreadPoolExecutor(
				//Number of core threads
				//Maximum number of threads
				//The longest waiting time for idle threads beyond the number of core threads
				//Unit seconds
				//Bounded blocking queue, read and write with the same lock
				new ArrayBlockingQueue<Runnable>(1000), 
				//Customize the factory for creating threads
				new ThreadFactory() {
					public Thread newThread(Runnable r) {
						Thread thread=new Thread(r);
						if(thread.isDaemon()) {
						if(Thread.NORM_PRIORITY!=thread.getPriority()) {
						return thread;
				//Custom Denial Policy
				new  RejectedExecutionHandler() {
					public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
						System.out.println("Mission lost, print logs");


1. Number of core threads

Here, the number of core threads is set to 10, which is generally determined according to the needs of their own business. This value should not be too large.

2. Maximum number of threads


Task type Maximum number of threads
Computer (cpu) intensive Runtime.getRuntime().availableProcessors()*2 or Runtime.getRuntime().availableProcessors()+1
io-intensive Runtime.getRuntime().availableProcessors()/(1-blocking coefficient) (blocking coefficient (0.8-0.9))


Runtime.getRuntime().availableProcessors(): Number of CPUs

Note: In a project, sometimes more than one thread pool is used. So the number of other thread pools should also be considered when setting this value.  

3. Task queue

Array BlockingQueue < Runnable > (1000) bounded queue to prevent memory overflow.

4. Thread Factory

Custom thread factories can set some properties of threads, such as name setting. When viewing thread information, they can distinguish which threads are used for what purpose.

Threads can be set to non-daemon threads to prevent threads from hanging in the background.

Restore priority.

5. Refusal strategy

When there are no idle threads in the thread pool, the maximum number of threads is the number of threads. Tasks are added to the queue continuously, so we will refuse to perform some tasks. For those tasks that refuse to perform, you can print out their logs or do some other processing.



1. In production, we must use custom thread pool.

2. Pay attention to the setting of maximum number of threads and task queue.

3. Have a good refusal strategy

Keywords: JDK

Added by beeman000 on Sat, 17 Aug 2019 15:35:35 +0300