WO2019148734A1

WO2019148734A1 - Uniform thread pool processing method, application server, and computer readable storage medium

Info

Publication number: WO2019148734A1
Application number: PCT/CN2018/090909
Authority: WO
Inventors: 彭捷
Original assignee: 平安科技（深圳）有限公司
Priority date: 2018-02-01
Filing date: 2018-06-12
Publication date: 2019-08-08
Also published as: CN108345499A; CN108345499B

Abstract

Disclosed in the present application is a uniform thread pool processing method, comprising: querying a persistent data table; obtaining a parameter of each thread pool in an execution queue according to the persistent data table, wherein the parameter of each thread pool comprises each thread pool name; respectively creating each thread pool object according to the parameter of each thread pool; creating a thread pool queue according to each thread pool name and each thread pool object; and managing each thread pool by means of the thread pool queue. The present application also provides an application server and a computer readable storage medium. The uniform thread pool processing method, application server, and computer readable storage medium provided by the present application can implement uniform management of each thread pool object, reduce system resource consumption, and improve system stability.

Description

Unified thread pool processing method, application server and computer readable storage medium

This application claims priority to Chinese Patent Application No. 201101102252.3, entitled "Unified Thread Pool Processing Method, Application Server, and Computer Readable Storage Media", which is filed on February 1, 2018, the entire contents of which are incorporated herein by reference. This is incorporated herein by reference.

Technical field

The present application relates to the field of data analysis technologies, and in particular, to a unified thread pool processing method, an application server, and a computer readable storage medium.

Background technique

At present, the thread pool has been widely used in Internet technology. By introducing a thread pool, it is possible to effectively manage threads, control the total number of thread ceilings, and reduce the overhead caused by creating and destroying threads. In practical applications, with the development of services, multiple services in the system also use thread pools, such as sensitive log bulk storage errors, re-entry tables, MQCP log receiving queues, and public cleanup services. The role of the thread pool is to limit the number of execution threads in the system. According to the environment of the system, the number of threads can be set automatically or manually to achieve the best effect of the operation; less system resources are wasted, and the system congestion is not high.

When a system increases the number of other system calls, the thread pool technology faces a new challenge: if the thread pool is not managed uniformly, it is prone to thread confusion or resource consumption in high concurrency, which seriously affects system stability. .

Summary of the invention

In view of this, the present application provides a unified thread pool processing method, an application server, and a computer readable storage medium to solve the problem that thread turbulence or resource consumption seriously affects system stability under high concurrency conditions.

First, in order to achieve the above object, the present application provides a unified thread pool processing method, the method comprising the steps of:

Query the persistent data table;

Obtaining, according to the persistent data table, parameters of each thread pool in the execution queue, where the parameters of each thread pool include each thread pool name;

Creating each thread pool object according to the parameters of each thread pool;

Creating a thread pool queue according to each of the thread pool names and each of the thread pool objects; and

Each of the thread pools is managed by the thread pool queue.

In addition, to achieve the above object, the present application further provides an application server, including a memory and a processor, where the memory stores a unified thread pool processing system executable on the processor, and the unified thread pool processing system The steps of the unified thread pool processing method as described above are implemented when executed by the processor.

Further, in order to achieve the above object, the present application further provides a computer readable storage medium storing a unified thread pool processing system, the unified thread pool processing system being executable by at least one processor, The step of causing the at least one processor to perform the unified thread pool processing method as described above.

Compared with the prior art, the unified thread pool processing method, the application server, and the computer readable storage medium proposed by the present application can obtain parameters of each thread pool by querying a persistent data table, and according to each thread pool. The parameters respectively create each thread pool object, and realize the unified creation of the thread pool; save the mapping relationship between each thread pool name and each of the thread pool objects by creating a thread pool queue, and implement according to the thread pool queue The unified management of each of the thread pool objects reduces the system resource consumption and improves the stability of the system.

DRAWINGS

1 is a schematic diagram of an optional hardware architecture of an application server of the present application;

2 is a schematic diagram of a program module of a first embodiment of a unified thread pool processing system of the present application;

3 is a schematic diagram of a program module of a second embodiment of a unified thread pool processing system of the present application;

4 is a schematic flowchart of a first embodiment of a unified thread pool processing method of the present application;

5 is a schematic flowchart of a second embodiment of a unified thread pool processing method of the present application;

FIG. 6 is a schematic flowchart diagram of a third embodiment of a unified thread pool processing method according to the present application.

Reference mark:

应用服务器application server	22
存储器Memory	1111
处理器processor	1212
网络接口Network Interface	1313
统一线程池处理系统Unified thread pool processing system	200200
查询模块Query module	201201
获取模块Acquisition module	202202
线程池对象创建模块Thread pool object creation module	203203
线程池队列创建模块Thread pool queue creation module	204204
管理模块Management module	205205

The implementation, functional features and advantages of the present application will be further described with reference to the accompanying drawings.

Detailed ways

In order to make the objects, technical solutions, and advantages of the present application more comprehensible, the present application will be further described in detail below with reference to the accompanying drawings and embodiments. It is understood that the specific embodiments described herein are merely illustrative of the application and are not intended to be limiting. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments of the present application without departing from the inventive scope are the scope of the present application.

It should be noted that the descriptions of "first", "second" and the like in the present application are for the purpose of description only, and are not to be construed as indicating or implying their relative importance or implicitly indicating the number of technical features indicated. . Thus, features defining "first" or "second" may include at least one of the features, either explicitly or implicitly. In addition, the technical solutions between the various embodiments may be combined with each other, but must be based on the realization of those skilled in the art, and when the combination of the technical solutions is contradictory or impossible to implement, it should be considered that the combination of the technical solutions does not exist. Nor is it within the scope of protection required by this application.

Referring to FIG. 1, it is a schematic diagram of an optional hardware architecture of the application server 2 of the present application.

In this embodiment, the application server 2 may include, but is not limited to, the memory 11, the processor 12, and the network interface 13 being communicably connected to each other through a system bus. It is pointed out that Figure 1 only shows the application server 2 with components 11-13, but it should be understood that not all illustrated components may be implemented, and more or fewer components may be implemented instead.

The application server 2 may be a computing device such as a rack server, a blade server, a tower server, or a rack server. The application server 2 may be an independent server or a server cluster composed of multiple servers. .

The memory 11 includes at least one type of readable storage medium including a flash memory, a hard disk, a multimedia card, a card type memory (eg, SD or DX memory, etc.), a random access memory (RAM), a static Random access memory (SRAM), read only memory (ROM), electrically erasable programmable read only memory (EEPROM), programmable read only memory (PROM), magnetic memory, magnetic disk, optical disk, and the like. In some embodiments, the memory 11 may be an internal storage unit of the application server 2, such as a hard disk or memory of the application server 2. In other embodiments, the memory 11 may also be an external storage device of the application server 2, such as a plug-in hard disk equipped on the application server 2, a smart memory card (SMC), and a secure digital number. (Secure Digital, SD) card, flash card, etc. Of course, the memory 11 can also include both the internal storage unit of the application server 2 and its external storage device. In this embodiment, the memory 11 is generally used to store an operating system installed on the application server 2 and various types of application software, such as program code of the unified thread pool processing system 200. Further, the memory 11 can also be used to temporarily store various types of data that have been output or are to be output.

The processor 12 may be a Central Processing Unit (CPU), controller, microcontroller, microprocessor, or other data processing chip in some embodiments. The processor 12 is typically used to control the overall operation of the application server 2. In this embodiment, the processor 12 is configured to run program code or process data stored in the memory 11, such as running the unified thread pool processing system 200 and the like.

The network interface 13 may comprise a wireless network interface or a wired network interface, which is typically used to establish a communication connection between the application server 2 and other electronic devices.

So far, the hardware structure and functions of the devices related to this application have been described in detail. Hereinafter, various embodiments of the present application will be made based on the above description.

First, the present application proposes a unified thread pool processing system 200.

Referring to FIG. 2, it is a program module diagram of the first embodiment of the unified thread pool processing system 200 of the present application.

In this embodiment, the unified thread pool processing system 200 includes a series of computer program instructions stored in the memory 11, and when the computer program instructions are executed by the processor 12, the unified thread pool of the embodiments of the present application can be implemented. Processing operations. In some embodiments, the unified thread pool processing system 200 can be divided into one or more modules based on the particular operations implemented by the various portions of the computer program instructions. For example, in FIG. 2, the unified thread pool processing system 200 can be divided into a query module 201, an acquisition module 202, a thread pool object creation module 203, and a thread pool queue creation module 204. among them:

The query module 201 is configured to query a persistent data table.

Specifically, the persistent data table needs to be read from a key-value database. In an embodiment, the key-value database may be a Redis database.

The persistent data table is used to store parameter information of each thread pool object in the execution queue, and the parameter information includes a thread pool name, a core thread number, a maximum thread number, a maximum queue length, and a queue type.

In this embodiment, the persistence method periodically performs a snapshot of Redis data in the memory according to a certain saving rule, and synchronizes the snapshot data to the hard disk. Each time the snapshot file is a binary that stores redis data. file.

The obtaining module 202 is configured to obtain, according to the persistent data table, parameters of each thread pool in the execution queue.

Specifically, the parameters of each thread pool include a thread pool name, a core thread number, a maximum thread number, a maximum queue length, and a queue type.

The core thread in the core thread number (corePoolSize) will always survive, even if no tasks need to be executed. When the number of running threads is less than the number of core threads, even if there are threads idle, the thread pool will give priority to creating new thread processing.

In an embodiment, when a task needs to be added to the first thread pool, if the number of threads running in the first thread pool is less than the number of core threads, the first thread pool immediately creates a thread to run the task; If the number of threads running in the pool is greater than or equal to the number of core threads, then this task is placed in the task queue of the first thread pool.

The maximum number of threads (maximumPoolSize) is used to indicate how many threads can be created in the thread pool.

In an embodiment, when a task needs to be added to the first thread pool, if the task queue of the first thread pool is full (that is, the maximum queue length has been reached), and the number of running threads is less than the maximum number of threads, then To create a new thread to run this task;

In a further embodiment, when a task needs to be added to the first thread pool, if the queue is full (ie, the maximum queue length has been reached) and the number of running threads is greater than or equal to the maximum number of threads, the first thread pool will Throw an exception.

The queue types include: direct submission queues, unbounded queues, and bounded queues.

The direct submission queue may be a SynchronousQueue. In an embodiment, the SynchronousQueue can be set as the default option for the work queue, which is submitted directly to the thread without queuing. If there is no thread available to run the task immediately, the direct commit queue fails to queue the task, so a new thread is constructed. This strategy avoids locks when dealing with request sets that may have internal dependencies. The direct commit queue typically requires an unbounded maximum number of threads to avoid rejecting newly submitted tasks. This strategy allows unbounded threads to grow as the command arrives continuously over the average that can be processed by the queue.

The bounded queue can be an ArrayBlockingQueue. The ArrayBlockingQueue is a bounded blocking queue based on an array structure. This queue sorts the elements according to the FIFO (first in, first out) principle.

The unbounded queue can be a LinkedBlockingQueue. LinkedBlockingQueue is a blocking queue based on linked list structure. This queue sorts elements by FIFO (first in first out), and the throughput is usually higher than ArrayBlockingQueue.

The thread pool object creation module 203 is configured to separately create each thread pool object according to the parameters of each thread pool.

Specifically, the thread pool is created through the java.uitl.concurrent.ThreadPoolExecutor class, and the specific creation method is:

Among them, keepAliveTime indicates that the thread will terminate when there is no task execution. Unit is the time unit of the parameter keepAliveTime; where threadFactory is the thread factory, which is used to create the thread; where the handler is the policy when the task is rejected.

In an embodiment, when the value of the handler is ThreadPoolExecutor.AbortPolicy, the task is discarded and a Rejected Execution Exception is thrown;

In an embodiment, when the value of the handler is ThreadPoolExecutor.DiscardPolicy, the task is discarded, but the Rejected Execution Exception is not thrown;

In an embodiment, when the value of the handler is ThreadPoolExecutor.DiscardOldestPolicy, the task at the top of the queue is discarded, and then the task is retried (repeating the process);

In one embodiment, when the handler takes a value of ThreadPoolExecutor.CallerRunsPolicy, the task is processed by the calling thread.

The thread pool queue creation module 204 is configured to create a thread pool queue according to the thread pool name and the thread pool object.

Specifically, the mapping relationship between the thread pool name and the corresponding thread pool object is saved as the thread pool queue.

In an embodiment, the mapping relationship between the thread pool name and the corresponding thread pool object may be represented as Map<ThreadPoolName, ThreadPool>, wherein the key of the Map class is the thread pool name, and the value is the thread pool. Object.

In a further embodiment, the mapping relationship between the second thread pool name and the corresponding second thread pool object may be added to the thread pool queue by map.put(ThreadPoolName2, ThreadPool2).

Referring to FIG. 3, it is a program module diagram of a second embodiment of the unified thread pool processing system 200 of the present application. In this embodiment, the unified thread pool processing system 200 includes a query module 201, an obtaining module 202, a thread pool object creating module 203, and a thread pool queue creating module 204 in the first embodiment, and a management module. 205.

The management module 205 is configured to manage each of the thread pools through the thread pool queue.

Specifically, the thread pool object corresponding to the thread pool name may be obtained by using Object get=map.get("ThreadPoolName"), and the thread pool object corresponding to the thread pool name is managed.

In a preferred embodiment, the management module 205 is specifically configured to:

Get the first thread pool name of the thread pool to be operated;

Obtaining, according to the first thread pool name, a corresponding first thread pool object from the thread pool queue;

Performing a management operation on the first thread pool object, the management operation may include: acquiring the first thread pool object thread number, submitting a task to the first thread pool object, and closing the first thread pool object.

In an embodiment, the number of threads currently active by the thread pool object corresponding to the thread pool name may be obtained by using the thread pool name.

Specifically, the number of threads currently active by the thread pool object corresponding to the thread pool name may be obtained by using a private volatile int poolSize.

In an embodiment, the length of the current execution queue of the thread pool object corresponding to the thread pool name may be obtained by the thread pool name.

In an embodiment, the task object to be started may be submitted to the specified thread pool object by using a thread pool name, parameter information, and a task object to be started.

Specifically, the task object to be started may be submitted to the specified thread pool object by execute() and submit().

In a further embodiment, the thread pool object after receiving the task object to be started:

When the number of threads currently active by the thread pool object is less than the number of core threads, the creation thread runs this task;

When the number of threads currently active by the thread pool object is greater than or equal to the number of core threads, the task is put into a queue;

When the number of threads currently active by the thread pool object is less than the maximum number of threads, create a new thread to run the task;

When the number of threads currently active by the thread pool object is greater than or equal to the maximum number of threads, the thread pool throws an exception.

In an embodiment, the thread pool object corresponding to the thread pool name may be closed by the thread pool name. Specifically, the thread pool object corresponding to the thread pool name may be closed by using shutdown() and shutdownNow(). Shutdown() does not terminate the thread pool immediately, but waits until all the tasks in the task cache queue have been executed, but will not accept the new task again; shutdownNow(): terminate the thread pool immediately and try Interrupts the task being executed and clears the task cache queue, returning tasks that have not yet been executed.

The unified thread pool processing system of the present application obtains the parameters of each thread pool by querying the persistent data table, and creates each thread pool object according to the parameters of each thread pool, thereby realizing the unified creation of the thread pool; The thread pool queue saves the mapping relationship between each thread pool name and each of the thread pool objects, and implements unified management of each of the thread pool objects according to the thread pool queue, thereby reducing system resource consumption and improving The stability of the system.

In addition, the present application also proposes a unified thread pool processing method.

Referring to FIG. 4, it is a schematic flowchart of the first embodiment of the unified thread pool processing method of the present application. In this embodiment, the order of execution of the steps in the flowchart shown in FIG. 5 may be changed according to different requirements, and some steps may be omitted.

Step S402, querying the persistent data table.

Step S404: Acquire, according to the persistent data table, parameters of each thread pool in the execution queue, where the parameters of each thread pool include each thread pool name.

The core thread in the core thread number (corePoolSize) will always survive, and no task needs to be executed in time. When the number of threads is less than the number of core threads, even if there is a thread idle, the thread pool will preferentially create a new thread for processing.

The maximum number of threads (maximumPoolSize) is used to indicate how many threads can be created in the thread pool:

Step S406, respectively creating each thread pool object according to the parameters of each thread pool.

Among them, corePoolSize represents the core pool size. After the thread pool is created, by default, there is no thread in the thread pool, but waiting for a task to arrive to create a thread to execute the task, unless the prestartAllCoreThreads() or prestartCoreThread() method is called. By default, after the thread pool is created, the number of threads in the thread pool is 0. When there is a task, a thread is created to execute the task. When the number of threads in the thread pool reaches the number of core threads, Put the arriving task in the cache queue;

Among them, maximumPoolSize represents the maximum number of threads in the thread pool, indicating how many threads can be created in the thread pool;

Among them, keepAliveTime indicates that the thread will terminate when there is no task execution. The unit is the time unit of the parameter keepAliveTime. The threadFactory is the thread factory and is used to create the thread. The handler is the strategy when the task is rejected.

Step S408, creating a thread pool queue according to each thread pool name and each of the thread pool objects.

As shown in FIG. 5, it is a schematic flowchart of a second embodiment of a unified thread pool processing method of the present application. In this embodiment, the steps S502-S508 of the unified thread pool processing method are similar to the steps S402-S408 of the first embodiment, except that the method further includes step S510.

The method includes the following steps:

Step S510, managing each thread pool through the thread pool queue.

Specifically, the thread pool object corresponding to the thread pool name may be obtained by using Object get=map.get("ThreadPoolName"), and the thread pool object corresponding to the thread pool name is managed. The specific steps will be described in detail in the third embodiment of the unified thread pool processing method of the present application (see FIG. 6).

FIG. 6 is a schematic flowchart diagram of a third embodiment of a unified thread pool processing method of the present application. In this embodiment, the step of managing the thread pool by using the thread pool queue includes:

Step 602: Obtain a first thread pool name of a thread pool to be operated.

Specifically, after receiving the operation instruction, extracting, according to the operation instruction, a first thread pool name of the thread pool to be operated.

Step 604: Obtain a corresponding first thread pool object from the thread pool queue according to the first thread pool name.

Specifically, the obtained first thread pool name is taken as a variable ThreadPoolName, and is delivered to the thread pool queue.

In an embodiment, the thread pool object corresponding to the thread pool name is obtained by Object get=map.get("ThreadPoolName").

Step 606: Perform a management operation on the first thread pool object.

Specifically, the managing operation may include: acquiring the first thread pool object thread number, submitting the task to the first thread pool object, and closing the first thread pool object.

The unified thread pool processing method of the present application obtains the parameters of each thread pool by querying the persistent data table, and creates each thread pool object according to the parameters of each thread pool, thereby realizing the unified creation of the thread pool; The thread pool queue saves the mapping relationship between each thread pool name and each of the thread pool objects, and implements unified management of each of the thread pool objects according to the thread pool queue, thereby reducing system resource consumption and improving The stability of the system.

The serial numbers of the embodiments of the present application are merely for the description, and do not represent the advantages and disadvantages of the embodiments.

Through the description of the above embodiments, those skilled in the art can clearly understand that the foregoing embodiment method can be implemented by means of software plus a necessary general hardware platform, and of course, can also be through hardware, but in many cases, the former is better. Implementation. Based on such understanding, the technical solution of the present application, which is essential or contributes to the prior art, may be embodied in the form of a software product stored in a storage medium (such as ROM/RAM, disk, The optical disc includes a number of instructions for causing a terminal device (which may be a mobile phone, a computer, a server, an air conditioner, or a network device, etc.) to perform the methods described in various embodiments of the present application.

The above is only a preferred embodiment of the present application, and is not intended to limit the scope of the patent application, and the equivalent structure or equivalent process transformations made by the specification and the drawings of the present application, or directly or indirectly applied to other related technical fields. The same is included in the scope of patent protection of this application.

Claims

A unified thread pool processing method is applied to an application server, and the method includes the following steps:

Query the persistent data table;

Obtaining, according to the persistent data table, parameters of each thread pool in the execution queue, where the parameters of each thread pool include each thread pool name;

Creating each thread pool object according to the parameters of each thread pool;

Creating a thread pool queue according to each of the thread pool names and each of the thread pool objects; and

Each of the thread pools is managed by the thread pool queue.
The unified thread pool processing method according to claim 1, wherein the parameters of each thread pool further include a core thread number, a maximum thread number, a maximum queue length, and a queue type.
The unified thread pool processing method according to claim 2, wherein the step of creating a thread pool queue according to each of the thread pool names and each of the thread pool objects comprises:

Obtaining a mapping relationship between each thread pool name and each thread pool object;

The Map class saves the mapping relationship between each thread pool name and each thread pool object and creates the thread pool queue.
The unified thread pool processing method according to claim 2, wherein the step of managing the each thread pool through the thread pool queue comprises:

Get the first thread pool name of the thread pool to be operated;

Obtaining, according to the first thread pool name, a corresponding first thread pool object from the thread pool queue;

Performing a management operation on the first thread pool object, the management operation may include: acquiring the first thread pool object thread number, submitting a task to the first thread pool object, and closing the first thread pool object.
The unified thread pool processing method according to claim 1, wherein the step of separately creating each thread pool object according to the parameters of each thread pool comprises:

Collecting parameters of each of the thread pools;

Create a thread pool through the java.uitl.concurrent.ThreadPoolExecutor class.
The unified thread pool processing method according to claim 2, wherein the step of separately creating each thread pool object according to the parameters of each thread pool comprises:

Collecting parameters of each of the thread pools;

Create a thread pool through the java.uitl.concurrent.ThreadPoolExecutor class.
The unified thread pool processing method according to claim 3 or 4, wherein the step of separately creating each thread pool object according to the parameters of each thread pool comprises:

Collecting parameters of each of the thread pools;

Create a thread pool through the java.uitl.concurrent.ThreadPoolExecutor class.
An application server, comprising: a memory, a processor, and a unified thread pool processing system executable on the processor, where the unified thread pool processing system is The processor implements the following steps when it executes:

Query the persistent data table;

Obtaining, according to the persistent data table, parameters of each thread pool in the execution queue, where the parameters of each thread pool include each thread pool name;

Creating each thread pool object according to the parameters of each thread pool;

Creating a thread pool queue according to each of the thread pool names and each of the thread pool objects; and

Each of the thread pools is managed by the thread pool queue.
The application server according to claim 8, wherein the parameters of each thread pool further include a core thread number, a maximum thread number, a maximum queue length, and a queue type.
The application server according to claim 9, wherein the step of creating a thread pool queue according to each of the thread pool names and each of the thread pool objects comprises:

Obtaining a mapping relationship between each thread pool name and each thread pool object;

The Map class saves the mapping relationship between each thread pool name and each thread pool object and creates the thread pool queue.
The application server according to claim 9, wherein the step of managing each of the thread pools by using the thread pool queue comprises:

Get the first thread pool name of the thread pool to be operated;

Obtaining, according to the first thread pool name, a corresponding first thread pool object from the thread pool queue;

Performing a management operation on the first thread pool object, the management operation may include: acquiring the first thread pool object thread number, submitting a task to the first thread pool object, and closing the first thread pool object.
The application server according to claim 8, wherein the step of separately creating each thread pool object according to the parameters of each thread pool comprises:

Collecting parameters of each of the thread pools;

Create a thread pool through the java.uitl.concurrent.ThreadPoolExecutor class.
The application server according to claim 9, wherein the step of separately creating each thread pool object according to the parameters of each thread pool comprises:

Collecting parameters of each of the thread pools;

Create a thread pool through the java.uitl.concurrent.ThreadPoolExecutor class.
The application server according to claim 10 or 11, wherein the step of separately creating each thread pool object according to the parameters of each thread pool comprises:

Collecting parameters of each of the thread pools;

Create a thread pool through the java.uitl.concurrent.ThreadPoolExecutor class.
A computer readable storage medium storing a unified thread pool processing system, the unified thread pool processing system being executable by at least one processor to cause the at least one processor to perform the following steps:

Query the persistent data table;

Obtaining, according to the persistent data table, parameters of each thread pool in the execution queue, where the parameters of each thread pool include each thread pool name;

Creating each thread pool object according to the parameters of each thread pool;

Creating a thread pool queue according to each of the thread pool names and each of the thread pool objects; and

Each of the thread pools is managed by the thread pool queue.
The computer readable storage medium according to claim 15, wherein the parameters of each thread pool further include a core thread number, a maximum thread number, a maximum queue length, and a queue type.
The computer readable storage medium according to claim 16, wherein the step of creating a thread pool queue according to each of the thread pool names and each of the thread pool objects comprises:

Obtaining a mapping relationship between each thread pool name and each thread pool object;

The Map class saves the mapping relationship between each thread pool name and each thread pool object and creates the thread pool queue.
The computer readable storage medium of claim 16, wherein the step of managing each of the thread pools by using the thread pool queue comprises:

Get the first thread pool name of the thread pool to be operated;

Obtaining, according to the first thread pool name, a corresponding first thread pool object from the thread pool queue;

Performing a management operation on the first thread pool object, the management operation may include: acquiring the first thread pool object thread number, submitting a task to the first thread pool object, and closing the first thread pool object.
The computer readable storage medium according to claim 15, wherein the step of separately creating each thread pool object according to the parameters of each thread pool comprises:

Collecting parameters of each of the thread pools;

Create a thread pool through the java.uitl.concurrent.ThreadPoolExecutor class.
The computer readable storage medium according to any one of claims 16 to 18, wherein the step of separately creating each thread pool object according to the parameters of each thread pool comprises:

Collecting parameters of each of the thread pools;

Create a thread pool through the java.uitl.concurrent.ThreadPoolExecutor class.