The interviewer asked me to turn left because of the thread pool!

A few days ago, my friend had an interview. During the interview, the interviewer asked about frameworks, projects, JVM and some thread pools. The thread pool was so confusing that my friend had to turn left and go home. Why? Because he didn't prepare for the thread pool, so he got nothing.

[[327119]]

Preface To be honest, when Afen was interviewing, at the beginning of the interview, the interviewer only asked what are the ways to implement multi-threading, but when you talked about the thread pool, you just mentioned it in one sentence, and some interviewers did not pay much attention to this. However, since the interviewers from Alibaba started asking questions about thread pools, this issue has become a high-frequency hot topic.

Then, Afen will continue to tell you about this thread pool and how to scare the interviewer in minutes.

1. What is a thread pool?

I don't know if you have carefully looked at the java.util.concurrent.Executors class, but this class provides me with many methods to create a thread pool.

As the comment at the beginning of the code states, it creates a thread pool that reuses a fixed number of threads. If other tasks are submitted when all threads are active, they will wait in the queue for threads to become available.

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

We create a thread pool to solve the problem of multiple thread execution within a processor unit. It can significantly reduce the idle time of the processor unit and increase the throughput of the processor unit.

During an interview, we definitely cannot say this. During an interview, we can say:

Those who work on Java, of course, know about thread pools. When we are developing, sometimes the tasks we need to do gradually increase, and the complexity will become stronger and stronger, so the number of threads will increase little by little, and the corresponding threads will occupy more and more resources. The release and cancellation of resources occupied by multiple threads need to be maintained, and the management of multiple threads becomes particularly important at this time. In response to this situation, Sun provides thread pools, a management tool for thread collections. So the thread pool appeared, and the next question from the interviewer is more ruthless, how do you usually use it, what are the common ones, after all, the interviewer's routine is one ring after another.

2. What are the common thread pools and where are they used?

At this time, the java.util.concurrent.Executors class comes in handy, for example:

(1) newSingleThreadExecutor

 A single-threaded thread pool means that only one thread in the thread pool works at a time, and a single thread executes tasks serially.
 public ThreadPoolExecutor( int corePoolSize,
 int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
 }

(2)newFixedThreadPool

The following two methods are overloads of this method, and their meaning is very clear. They establish a thread pool with a fixed number of threads and a specified maximum number of threads. Tasks that come in after exceeding this number will be placed in the waiting queue. If there are idle threads, they will be obtained from the waiting queue, following the first-in-first-out principle.

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

(3)newCacheThreadExecutor

The cached thread pool means that before the core thread reaches the maximum value, if there are more tasks coming in, new core threads will be created and added to the core thread pool. Even if there are idle threads, they will not be reused.

When the maximum number of core threads is reached, new tasks come in. If there are idle threads, they are used directly. If there are no idle threads, new temporary threads are created.

The cached thread pool uses SynchronousQueue as the waiting queue. It does not save any tasks. When a new task is added, it will create a temporary thread for use.

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

(4)newScheduledThreadPool

Scheduled Thread Pool, as explained very clearly in its comments, creates a thread pool that can be scheduled to execute at a given delay, or periodically.

That is to say, when a new task arrives, we check whether there is an idle thread. If there is, we use it directly. If not, we add a new thread to the pool. The DelayedWorkQueue is used as the waiting queue. After a certain waiting time, the task will continue to be executed.

 public   static ScheduledExecutorService newScheduledThreadPool( int corePoolSize) {
 return new ScheduledThreadPoolExecutor(corePoolSize);
 } 
     
 public   static ScheduledExecutorService newScheduledThreadPool(
 int corePoolSize, ThreadFactory threadFactory) {
 return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
 }

3. Have you read the Alibaba Development Manual? What does it say about threads? To be honest, I really didn't pay much attention to the use of threads in the Alibaba Development Manual at first, but the interviewer obviously must have read it when he asked this question. After that, I read the Alibaba Development Manual and couldn't help but sigh, Alibaba is really...

We will see this code in our daily use:

 ExecutorService cachedThreadPool=Executors.newFixedThreadPool();

But Alibaba said, sorry, mandatory thread pools are not allowed to be created using Executors

So what should I do? The recommended one is ThreadPoolExecutor.

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

There are several parameters in this method.

• corePoolSize The number of threads to be retained in the pool, that is, the size of the thread pool core pool
• maximumPoolSize Maximum number of threads
• keepAliveTime When the number of threads is greater than the cores, this is the maximum time that excess idle threads will wait for new tasks before terminating.
• unit The time unit of the keepAliveTime parameter
• workQueue is a queue used to store tasks waiting to be executed.
• threadFactory Thread Factory
• handler The default rejection handler

These parameters are also often asked in interviews. As for how to choose a suitable thread pool and how to reasonably configure the thread pool size, please continue to pay attention to Ah Fen. Ah Fen will take you in the next few days. Click to watch before leaving.