newCachedThreadPool method

Another type of thread pool is "cached". Such thread pools are just as commonly used as fixed ones.

As indicated by the name, this kind of thread pool caches threads. It keeps unused threads alive for a limited time in order to reuse those threads to perform new tasks. Such a thread pool is best for when we have some reasonable amount of light work.

The meaning of "some reasonable amount" is rather broad, but you should know that such a pool is not suitable for every number of tasks. For example, suppose we want to create a million tasks. Even if each takes a very small amount of time, we will still use an unreasonable amount of resources and degrade performance. We should also avoid such pools when the execution time is unpredictable, for example, with I/O tasks.

Under the hood, the ThreadPoolExecutor constructor is called with the following arguments:

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

The following values are passed to the constructor as arguments:

And we can pass our own implementation of ThreadFactory in exactly the same way.

Let's talk about SynchronousQueue

The basic idea of a synchronous transfer is quite simple and yet counter-intuitive (that is, intuition or common sense tells you that it is wrong): you can add an element to a queue if and only if another thread receives the element at the same time. In other words, a synchronous queue cannot have tasks in it, because as soon as a new task arrives, the executing thread has already picked up the task.

When a new task enters the queue, if there is a free active thread in the pool, then it picks up the task. If all the threads are busy, then a new thread is created.

A cached pool starts with zero threads and can potentially grow to Integer.MAX_VALUE threads. Essentially, the size of a cached thread pool is limited only by system resources.

To conserve system resources, cached thread pools remove threads that are idle for one minute.

Let's see how it works in practice. We'll create a task class that models a user request:

public class Task implements Runnable {
   int taskNumber;

   public Task(int taskNumber) {
       this.taskNumber = taskNumber;
   }

   @Override
   public void run() {
       System.out.println("Processed user request #" + taskNumber + " on thread " + Thread.currentThread().getName());
   }
}

In the main method, we create newCachedThreadPool and then add 3 tasks for execution. Here we print the status of our service (1).

Next, we pause for 30 seconds, start another task, and display the status (2).

After that, we pause our main thread for 70 seconds, print the status (3), then again add 3 tasks, and again print the status (4).

In places where we display the status immediately after adding a task, we first add a 1-second sleep for up-to-date output.

ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 3; i++) {
            executorService.submit(new Task(i));
        }

        TimeUnit.SECONDS.sleep(1);
            System.out.println(executorService);	//(1)

        TimeUnit.SECONDS.sleep(30);

        executorService.submit(new Task(3));
        TimeUnit.SECONDS.sleep(1);
            System.out.println(executorService);	//(2)

        TimeUnit.SECONDS.sleep(70);

            System.out.println(executorService);	//(3)

        for (int i = 4; i < 7; i++) {
            executorService.submit(new Task(i));
        }

        TimeUnit.SECONDS.sleep(1);
            System.out.println(executorService);	//(4)
        executorService.shutdown();

And here's the result:

Let's go over each of the steps:

Well, now you're acquainted with the logic of another type of executor service.

By analogy with other methods of the Executors utility class, the newCachedThreadPool method also has an overloaded version that takes a ThreadFactory object as an argument.