How powerful is pooling technology? I was shocked by the comparison between threads and thread pools!

[[335212]]

This article is reprinted from the WeChat public account "Java Chinese Community", written by Lei Ge. Please contact the Java Chinese Community public account to reprint this article.

People with high emotional intelligence can understand and take care of the emotions of everyone around them, and good articles should be understandable to everyone.

Nietzsche once said: People cannot understand what they have not experienced. Therefore, I will try to write technical articles as concretely as possible so that everyone can understand them. So before we officially start, let's start with two real-life examples.

Nietzsche's handsome photo:

[[335213]]

Chat: I used to think that Nietzsche was a Chinese saint, roughly the same as Zhuangzi. Later I found out that he was a foreigner. I was shocked.

Real life case 1

A few years ago, Taobao’s Double 11 suddenly became popular, and then countless men and women went crazy “shopping”. However, the most painful thing was not the days of eating “ashes” after “shopping”, but the long and heart-wrenching days of waiting for the courier.

[[335214]]

In order to alleviate each other's "pain" (the courier companies' phones were flooded with calls and users were getting impatient), the courier companies later became "smarter". Before every shopping festival, the courier companies would prepare sufficient people and vehicles in advance to meet the incoming orders.

From now on, when we encounter various shopping festivals, we no longer have to stare at our phones and wait anxiously for the courier every day.

Real life case 2

Xiaomei is an HR in a company. The beginning of every year is her most troublesome time. Because a large number of employees leave at the beginning of the year, Xiaomei needs to handle the formalities of the resigned employees while frantically recruiting people. In addition to these tasks, Xiaomei also has to endure intermittent urging from various departments and the big boss, all of which makes Xiaomei miserable.

So in order to deal with this embarrassing situation at the beginning of each year, Xiaomei became smarter. She would recruit some employees in advance at the end of each year to prepare for unexpected needs in the coming year.

Ever since using this trick (hiring people in advance), Xiaomei has lived a happy life.

[[335215]]

concept

Pooling technology refers to preparing some resources in advance and reusing these pre-prepared resources when needed.

That is to say, pooling technology has two advantages:

1. Create in advance;
2. Reuse.

Analysis of the advantages of pooling technology

For example, when creating an object in Java, the following steps are performed:

1. According to the parameters following the new identifier, the symbolic reference of the class is searched in the constant pool;
2. If the symbol application is not found (the class is not loaded), load, parse, and initialize the class;
3. The virtual machine allocates memory in the heap for the object, initializes the allocated memory to 0, and establishes a corresponding description structure for the object header (time-consuming operation: it is necessary to find the free area in the heap, modify the memory allocation status, etc.);
4. Call the object's initialization method (time-consuming operation: user's complex logic verification operations, such as IO, whether numerical calculations comply with regulations, etc.).

As can be seen from the above process, creating a class requires complex and time-consuming operations, so we should try to reuse existing classes to ensure efficient operation of the program. Of course, it would be even better if these classes could be created in advance, and these functions can be achieved using pooling technology.

Common applications of pooling technology

Common pooling technologies include: thread pool, memory pool, database connection pool, HttpClient connection pool, etc. Let's take a look at them one by one.

1. Thread Pool

The principle of thread pool is very simple, similar to the concept of buffer in operating system. A number of threads will be started in the thread pool first, and these threads are in sleep state. When the client has a new request, a sleeping thread in the thread pool will be awakened to process the client's request. After processing the request, the thread will go back to sleep.

Thread pools can greatly improve program performance. For example, there is a provincial bank network center with a large data collection. During peak hours, the number of concurrent client requests per second exceeds 100. If a new thread is created for each client request, the CPU time and memory consumed are very alarming. If a thread pool with 200 threads is used, a large amount of system resources will be saved, allowing more CPU time and memory to handle actual business applications instead of frequent thread creation and destruction.

2. Memory Pool

How to better manage the use of application memory and improve the frequency of memory use is a question that every developer should think about. Memory Pool provides a feasible solution.

When creating a memory pool, a large enough memory will be allocated in advance to form a preliminary memory pool. Then, each time a user requests memory, a free memory block in the memory pool will be returned, and the flag of this memory block will be set to used. When the memory is released after use, it is not a real process of calling free or delete, but a process of putting the memory back into the memory pool, and the flag must be set to free during the return process. Finally, when the application ends, the memory pool will be destroyed and each piece of memory in the memory pool will be released.

Advantages of memory pool:

• Reduce the generation of memory fragmentation. This advantage can be seen from the process of creating a memory pool. When we create a memory pool, we allocate relatively regular memory blocks to reduce the generation of memory fragmentation.
• The frequency of memory usage is increased. This can be seen from the process of allocating and releasing memory. Each allocation and release does not call the function or operator provided by the system to operate the actual memory, but reuses the memory in the memory pool.

Disadvantages of memory pool: It will cause waste of memory, because to use the memory pool, you need to allocate a large block of idle memory at the beginning, and not all of this memory may be used.

3. Database connection pool

The basic idea of ​​database connection pool is to store database connection as an object in memory when the system is initialized. When the user needs to access the database, instead of establishing a new connection, an established idle connection object is taken out from the connection pool. After use, the user does not close the connection, but puts the connection back into the connection pool for the next request to access. The establishment and disconnection of these connections are managed by the connection pool itself.

At the same time, you can also set the connection pool parameters to control the initial number of connections in the connection pool, the upper and lower limits of the connection, the maximum number of uses of each connection, the maximum idle time, etc. Of course, you can also monitor the number and usage of connections through the connection pool's own management mechanism.

4.HttpClient connection pool

We often use HttpClient to access HTTP services. In our project, there is a function that uses HttpClient to obtain the task execution status. It is requested once a second, and Conection Reset exceptions often occur. After analysis, it is found that the problem is that each request of HttpClient will create a new connection. When the frequency of creating connections is greater than the frequency of closing connections, it will cause a large number of connections in the TIME_CLOSED state in the system. At this time, using a connection pool to reuse connections can solve this problem.

Practice: Threads vs. Threads

Let's test how big the time difference is between the execution of the thread and the thread pool. The test code is as follows:

 import java.util.concurrent.LinkedBlockingDeque;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit; 
 
 /**
 * Thread pool vs thread performance comparison
 */
 public class ThreadPoolPerformance {
 // Maximum number of executions
 public   static final int maxCount = 1000; 
 
 public   static void main(String[] args) throws InterruptedException {
 //Thread test code
        ThreadPerformanceTest(); 
 
 //Thread pool test code
        ThreadPoolPerformanceTest();
 } 
 
 /**
 * Thread pool performance test
 */
    private static void ThreadPoolPerformanceTest() throws InterruptedException {
 // Start time
        long stime = System.currentTimeMillis();
 //Business code
        ThreadPoolExecutor tp = new ThreadPoolExecutor(10, 10, 0,
                TimeUnit.SECONDS, new LinkedBlockingDeque<>());
 for ( int i = 0; i < maxCount; i++) {
            tp.execute (new PerformanceRunnable());
 }
 tp.shutdown();
 tp.awaitTermination(1, TimeUnit.SECONDS); // Wait for thread pool execution to complete
 // End time
        long etime = System.currentTimeMillis();
 // Calculate execution time
 System. out .printf( "Thread pool execution time: %d milliseconds." , (etime - stime));
        System. out .println();
 } 
 
 /**
 * Thread performance test
 */
    private static void ThreadPerformanceTest() {
 // Start time
        long stime = System.currentTimeMillis();
 // Execute business code
 for ( int i = 0; i < maxCount; i++) {
            Thread td = new Thread(new PerformanceRunnable());
 td.start();
 try {
 td.join (); // Ensure thread execution is complete
            } catch (InterruptedException e) {
                e.printStackTrace();
 }
 }
 // End time
        long etime = System.currentTimeMillis();
 // Calculate execution time
 System. out .printf( "Thread execution time: %d milliseconds." , (etime - stime));
        System. out .println();
 } 
 
 //Business execution class
 static class PerformanceRunnable implements Runnable {
 @Override
 public void run() {
 for ( int i = 0; i < maxCount; i++) {
                long num = i * i + i;
 }
 }
 }
 }

The execution result of the above program is shown in the figure below:

In order to prevent the order of execution from affecting the test results, I will reverse the thread pool and thread calling methods. The execution results are shown in the following figure:

Summary From the test results of threads and thread pools, when we use pooling technology, the performance of the program can be improved by 10 times. This test result does not represent the quantitative performance result of pooling technology, because the test result is affected by the execution method and the number of loops, but the huge performance difference is enough to illustrate the advantages of pooling technology.

Coincidentally, Alibaba's "Java Development Manual" also stipulates that "thread resources must be provided by the thread pool, and explicit creation of threads in the application is not allowed" as follows:

Therefore, mastering and using pooling technology is a standard requirement for a qualified programmer. Do you know any other commonly used pooling technologies? You are welcome to leave a message in the comment area to add to it.

References & Citations

https://zhuanlan.zhihu.com/p/32204303

https://www.cnblogs.com/yanggb/p/10632317.html

Original link: https://mp.weixin.qq.com/s/ZraWOaOdYAJA7TV3Zx60Xw