Shulou(Shulou.com)06/03 Report--

This article focuses on "how to quickly fix the thread pool", interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn "how to fix the thread pool quickly".

Preface

1. Why create a thread pool?

2. What are the ways to create a thread pool?

3. How many common thread pools can Executors create?

4. What are the parameters of thread pool?

5. Can you talk about the principle of thread pool?

6. What are the rejection strategies in the thread pool?

7. Blocking queues are used in the thread pool, so what blocking queues do you know?

8. How to set up the core threads in the thread pool?

9. Do you know the states of the thread pool?

10. How are threads in the thread pool reused?

11. What's the difference between the submit () and execute () methods in the Java thread pool?

Overall diagram of thread pool

1. Why create a thread pool?

It is not enough to learn that threads do not understand thread pools, because thread pools are usually involved when we use threads.

The database also has connection pooling, which is called pooling technology.

Threads also have thread pools. There are two keys to the concept of pooling:

Control the number of resources

Reuse of resources

To answer the question of why to create a thread pool, we can talk about its three advantages.

First, reduce resource consumption. By reusing threads in the thread pool, we can avoid the resource consumption caused by our constant creation and destruction of threads.

Second, improve the response speed. When a task arrives in the thread pool, the task can be executed without waiting for the thread to be created.

Third, improve the manageability of threads. As we all know, threads are scarce resources. If created indefinitely, it will not only consume system resources, but also reduce the stability of the system. Using thread pools, you can uniformly allocate, tune, and monitor.

After answering the benefits of the above three thread pools, the interviewer will certainly continue to ask: what are the ways to create a thread pool?

2. What are the ways to create a thread pool?

There are two ways to create threads in java:

Executors

ThreadPoolExecutor

Both of these are under the juc directory. Where Executors can be understood as a utility class that is used to generate thread pools. In addition, most of the way Executors creates threads ends up using ThreadPoolExecutor.

And in the Ali specification, it is recommended that you do not use Executors to create thread pools. Because the type of thread pool and thread-related parameters are encapsulated in Executors, if we use it improperly in the code, it may cause problems with the system. It is recommended that you use ThreadPoolExecutor to create threads, and then create a thread pool according to your own business situation.

3. How many common thread pools can Executors create?

As we mentioned above, there are two ways to create a thread pool.

In fact, what most interviewers want us to answer is how many ways Executors creates thread pools? So I'm sure to continue to ask how Executors creates thread pools. Let's see how to answer this question today.

We can think of the Executors class as a factory class, which provides us with six ways to create thread pools:

The first, newSingleThreadExecutor, creates a single-threaded thread pool that ensures that all tasks are executed in the order in which they are submitted. In other words, there is only one thread in this pool.

The second, newFixedThreadPool, creates a thread pool with a specified number of threads

The third, newCachedThreadPool, creates a cacheable thread pool that is scalable, dynamically adjusted, and recycled for 60s.

The fourth, newScheduledThreadPool, creates a thread pool of unlimited size.

The fifth, newSingleThreadScheduledExecutor (), creates a singleton thread pool that executes tasks on a regular or delayed basis, which is used in many frameworks to achieve timing heartbeat detection.

The sixth, newWorkStealingPool, is a new way for Java 8 to create a thread pool.

After answering the above, the interview will ask: what are the parameters of the thread pool?

4. What are the parameters of thread pool?

This question can be regarded as an old-fashioned interview question, but the frequency in the interview is quite high and enduring.

There are seven parameters in the thread pool:

The first, maximumPoolSize, refers to the maximum number of threads

The second, corePoolSize, refers to the number of core threads

The third, keepAliveTime, refers to the maximum thread active time.

Fourth, unit: specifies the unit of keepAliveTime, which can be milliseconds, seconds, minutes, hours, etc.

The fifth, workQueue: the queue that stores outstanding tasks

Sixth, threadFactory: the factory that creates the thread, if not specified, uses the default thread factory

The seventh, handler: specifies the processing policy for newly added tasks when the task queue is full and there are no available threads to execute the task

In the interview, it is OK if you can name the five core parameters: maximumPoolSize, corePoolSize, keepAliveTime, workQueue and Handler, but it is recommended that everyone answer all seven parameters.

5. Can you talk about the principle of thread pool?

In the interview, I like to answer this question with examples from life, please see how I answer it:

In a factory, when the order comes, the regular employees begin to produce parts. However, there are more and more orders, and regular employees can't handle them, so they put the tasks in the warehouse first, but when the orders are full, the warehouse can't hold them. At this time, the factory will think of finding some temporary workers to help produce parts. If there are too many orders, the factory may find a way to turn down those orders that are not very profitable. At the same time, there are bad times when the factory may clean up temporary workers and ask them to come back to help later when they are busy.

Here, the order is the thread we created, the factory is the thread pool, the regular employee is the core thread, the temporary worker is the largest thread, the warehouse is the blocking queue, and if there are too many orders, we will consider the profit of the order. That is to say, if the profit is too small, then quit, this is the rejection strategy.

It is suggested to understand it in combination with the previous overall diagram.

6. What are the rejection strategies in the thread pool?

In the thread pool core parameters, a very important parameter is the rejection strategy, the interviewer is also very fond of asking, you can answer this.

There are four main deny policies in the thread pool:

The first, AbortPolicy, which is the default policy, means to discard the task and throw an exception

The second, CallerRunsPolicy, simply means that the queued thread is waiting, and the rejected task is running in the main thread, so the main thread is blocked, and other tasks will not be submitted to the thread pool until the rejected task has been executed.

The third, DiscardOldestPolicy, means to discard the longest task in the queue and execute the current task.

The fourth, DiscardPolicy, discards the task directly and does not throw an exception.

We've finished talking about one of the thread pool core parameters, and some interviewers like to ask another parameter, which is the blocking queue.

7. Blocking queues are used in the thread pool, so what blocking queues do you know?

This problem also belongs to the content of the java collection framework, so it is necessary to grasp it.

There are 7 kinds of blocking queues for JDK7 and beyond:

The first, ArrayBlockingQueue, is a bounded blocking queue consisting of array structures.

The second, LinkedBlockingQueue, is a bounded blocking queue composed of linked list structures.

The third, PriorityBlockingQueue, supports unbounded blocking queues for prioritization.

The fourth, DelayQueue, uses priority queues to implement unbounded blocking queues.

The fifth, SynchronousQueue, does not store blocking queues for elements.

The sixth, LinkedTransferQueue, is an unbounded blocking queue composed of linked list structures.

The seventh kind, LinkedBlockingDeque, is a two-way blocking queue composed of linked list structures.

In addition, LinkedBlockingDeque is the most commonly used in Executors, and SynchronousQueue is also used.

After answering the above seven, please remember to emphasize the two used in Executors to show that you are very familiar with them.

It is also possible to continue to ask a very important parameter, which is the number of core threads.

8. How to set up the core threads in the thread pool?

To answer this question, we first need to know that threads are related to CPU, so how to set the number of core threads must also be related to CPU, and the number of core threads is also related to the type of task. There are two types of tasks:

One is CPU-intensive, such as encryption and decryption, compression, computing and a series of tasks that consume a lot of CPU resources, which are pure CPU computing in most scenarios. Therefore, the number of core threads can be set to: number of core threads = number of CPU + 1.

Another is IO-intensive, such as MySQL database, file reading and writing, network communication and other tasks, this kind of task will not particularly consume CPU resources, but IO operation is more time-consuming and will take more time. Therefore, the number of core threads can be set to: number of core threads = number of CPU * 2.

This is only a theoretical value, the specific setting size, it is recommended to debug the relative optimal parameter size in the local, test, quasi-production environment.

After answering these questions, some interviewers may ask: do you know the status of the thread pool?

9. Do you know the states of the thread pool?

Many people, usually do not know that the thread pool actually has a state, only know the thread state. So if you are not prepared for this kind of question, you must hang up as long as you are asked.

The thread pool has five states

The first, RUNNING, refers to the initialization state of the thread pool, which can add tasks to be executed.

The second type, SHUTDOWN, means that the thread pool is in a state of waiting to be closed, does not receive new tasks, and only processes received tasks.

The third type, STOP, means that the thread pool closes immediately, does not receive new tasks, abandons tasks in the cache queue, and interrupts tasks that are being processed.

The fourth, TIDYING, refers to the thread pool self-collating state, which we can call the terminated () method to clean up the thread pool.

The fifth, TERMINATED, refers to the thread pool termination state.

After answering the thread pool status, the following question is very classic and basically for intermediate and advanced levels.

10. How are threads in the thread pool reused?

Thread reuse here refers to the reuse of threads in the thread pool. Note here that many people may not understand this! Emphasize it again

The thread we created manually is put into the thread pool, and in fact, it becomes a task at this time.

When the thread pool performs these tasks, instead of calling the start () method of the thread (task), the thread in the thread pool performs these tasks.

Then the threads in the thread pool keep looping, performing the tasks we throw in, and calling the run () method of those tasks. The run () method called at this point is equivalent to calling the put method of a normal object, performing all tasks by reusing these fixed threads.

11. What's the difference between the submit () and execute () methods in the Java thread pool?

I don't know if you remember that when we created a thread and then committed it to the thread pool, there were usually two ways: submit and execute. So the interviewer is likely to ask this question, and it is also likely to appear in the written exam.

To answer this question, we have to first talk about the similarities between the two.

Both the submit () and execute () methods are used to submit a task, which means that the task we created is submitted to the thread pool.

The difference between the two is that calling the execute () method to submit a task does not get the return value of the task, while calling submit () can use the Future to receive the return value of the task executed by the thread pool.

It can be thought of here that there are ways in which we can get the return value of the thread or not in the way we create the thread.

In addition, the execute () method is the method of ThreadPoolExecutor, while the submit () method is a method in the parent class AbstractExecutorService of ThreadPoolExecutor.

At this point, I believe you have a deeper understanding of "how to quickly fix the thread pool". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.