CN103268247A - Method and device for task execution and adjusting the number of reserved threads in thread pool - Google Patents

Abstract

The invention discloses a method for executing a task and adjusting the number of remaining threads in a thread pool and a device for executing the task and adjusting the number of the remaining threads in the thread pool. The method comprises the steps that the frequency of non-task operation in a period is counted periodically; the number of the remaining threads in the thread pool in the next period is determined according to the frequency, counted in the period, of the non-task operation; the determined number of the remaining threads in the thread pool in the next period is compared with the number of the remaining threads in the current thread pool, the remaining threads in the current thread pool are adjusted according to the compared result, and the remaining threads with the number adjusted in the next period are obtained; the number of the remaining threads in the thread pool is adjusted periodically through the method and the task is executed, so that system resource consumption of the non-task operation in the working process of the thread pool is reduced, the speed of response to the task is guaranteed, and system resources occupied are further reduced.

Description

Method and device for task execution and adjusting the number of reserved threads in thread pool

technical field

The invention relates to the field of computer technology, in particular to a task execution technology based on adjusting the number of reserved threads in a thread pool.

Background technique

At present, software such as operating systems or application programs of servers, switches, mobile communication terminals and other equipment often need to process a huge number of task requests per unit time, but the processing time of a single task is relatively short. The traditional multi-threading solution adopts the strategy of "instant creation, instant destruction": once a task is received, a new thread is created immediately, and the thread executes the task; after the task is executed, the thread exits. Although compared with creating a process, the time for creating a thread has been greatly shortened, but if the task submitted to the thread has a short execution time and the number of executions is extremely frequent, the system resources consumed by non-task operations such as creating and destroying threads cannot be used. Neglected, it will even be several times the system resources consumed by the execution of the task itself, resulting in the consumption of system resources by a large number of non-task operations, which not only slows down the response speed of the task program, but also affects the operation of other software on the same server.

Therefore, the thread pool technology is introduced in the software to reduce the consumption of system resources by reusing the created threads to reduce the consumption caused by thread creation and destruction; when the task arrives, the task can be executed without waiting for the thread creation to improve the response speed . Software using thread pool technology generally has the following components:

Thread pool manager: used to create and manage threads and other functional units in the thread pool.

Worker thread: The thread in the thread pool that actually executes the task.

Task interface: the functional unit that the thread pool accepts tasks.

Task queue: a functional unit that stores tasks to be executed by worker threads, where tasks are sorted according to the first-in-first-out principle.

After the software using the thread pool technology is started, the thread pool manager immediately pre-creates a certain number of worker threads in the thread pool as reserved threads, and marks them as idle. After the thread pool manager accepts the task through the task interface, it selects any idle reserved thread, and transfers the task to this thread for execution. When the reserved threads are executing tasks, the thread pool manager will store the tasks in the task queue; when there is no space left in the task queue, the thread pool manager will automatically create a certain number of worker threads as extended threads for processing updates. many tasks. After the task is executed, the thread does not exit immediately, but continues to wait for the next task in the pool. After the extended thread is idle for a period of time, it is destroyed by the thread pool manager to reclaim system resources; after the reserved thread is idle for a period of time, it is marked as idle by the thread pool manager but not destroyed.

In the existing technical solution of thread pool, the number of reserved threads is generally fixed, and can be adjusted manually in a few cases, but the software using thread pool technology needs to be restarted, and the number of reserved threads cannot be automatically adjusted. Due to the unpredictable fluctuation of the number of tasks, when the task interface of the thread pool receives a large number of tasks within a certain period of time, and the reserved thread is too late to process these tasks within the specified time limit, the thread pool manager needs to perform more task queue operations. It is also necessary to create a large number of extended threads; when the number of tasks falls back and remains for a period of time, and the extended threads are idle, the thread pool manager needs to destroy the extended threads, and some reserved threads may also be idle.

To sum up, the technical solution of retaining a fixed number of threads in the thread pool of the prior art will increase the consumption of system resources by non-task operations and reduce the response speed to tasks when the number of tasks is large; when the number of tasks is small, redundant Idle reserved threads consume more system resources.

Contents of the invention

Embodiments of the present invention provide a method and device for adjusting task execution and reserved threads of a thread pool, which are used to cope with tasks with varying numbers, occupy or consume less system resources, and ensure response speed to tasks.

The technical solution of the present invention improves a method for adjusting the number of reserved threads in the thread pool, including:

the frequency of non-task operations within a periodic statistical period; and

According to the frequency of non-task operations counted in this period, determine the number of reserved threads in the thread pool for the next period;

Compare the determined number of reserved threads in the thread pool for the next cycle with the number of reserved threads in the current thread pool, adjust the reserved threads in the current thread pool according to the comparison result, and obtain the adjusted reserved threads for the next cycle ;

Preferably, the non-task operations include: extended thread operations; wherein, the extended thread operations specifically include: operations of creating an extended thread and destroying an extended thread.

Preferably, the non-task operation further includes: a task queue operation; wherein, the task queue operation is specifically an operation of storing a task in the task queue.

Preferably, the frequency of non-task operations within the periodical statistical period specifically includes:

At the beginning of each cycle, the frequency of non-task operations in this cycle is cleared to 0;

During this period, count the frequency of non-task operations in the process of tasks whose execution quantity changes in the current thread pool.

Preferably, the number of reserved threads in the thread pool of the next cycle is determined according to the frequency of non-task operations counted in this cycle, specifically including:

Compare the frequency of non-task operations counted in the current period with several frequency thresholds:

If there is a frequency threshold less than the frequency of the non-task operation, then determine the maximum frequency threshold less than the frequency thresholds of the non-task operation frequency, and use the suggested number of reserved threads corresponding to the maximum frequency threshold as the next cycle The number of threads reserved in the thread pool;

Otherwise, use the number of non-idle reserved threads in this cycle as the number of reserved threads in the thread pool for the next cycle;

Alternatively, the number of reserved threads in the thread pool of the next cycle is determined according to the frequency of non-task operations counted in this period, specifically including:

The current cycle is decomposed into n sub-cycles, n is a natural number, and the non-task operation frequency counted in the current cycle is decomposed into n non-task operation sub-frequency statistics respectively in n sub-cycles; The operator sub-frequency is compared with several frequency thresholds respectively:

If there are frequency thresholds less than n sub-frequency of the non-task operation, determine the maximum frequency threshold in each frequency threshold less than n sub-frequency of the non-task operation, and suggest the reserved thread corresponding to the maximum frequency threshold The number is used as the number of reserved threads in the thread pool for the next cycle;

Otherwise, use the number of non-idle reserved threads in this cycle as the number of reserved threads in the thread pool for the next cycle;

Wherein, each of the frequency thresholds and the corresponding recommended number of reserved threads are preset natural numbers.

Preferably, the number of reserved threads in the determined next cycle thread pool is compared with the number of reserved threads in the current thread pool, and the reserved threads in the current thread pool are adjusted according to the comparison result to obtain the number of reserved threads in the next cycle. Adjusted number of reserved threads, including:

Calculate the difference between the determined number of reserved threads in the thread pool of the next cycle and the number of reserved threads in the current thread pool;

If the calculated difference is greater than 0, then create a number of reserved threads corresponding to the difference in the thread pool; The corresponding number of reserved threads are destroyed.

The technical solution of the present invention also provides a task execution method, including:

After receiving the task, the thread pool manager judges whether there are idle reserved threads in the current thread pool;

If so, assign the task to one of the idle reserved threads for execution; otherwise:

The thread pool manager judges whether the task queue of the current thread pool has remaining space; if there is remaining space, the thread pool manager stores the task in the task queue; if there is no remaining space, the thread pool manager Create a set number of extension threads in the thread pool, and assign tasks to be executed in the task queue to the extension threads for execution;

Wherein, the number of reserved threads in the thread pool is adjusted according to the following method:

The frequency of non-task operations in the periodic statistical period;

According to the frequency of non-task operations counted in this period, determine the number of reserved threads in the thread pool for the next period;

Compare the determined number of reserved threads in the thread pool for the next cycle with the number of reserved threads in the current thread pool, adjust the reserved threads in the current thread pool according to the comparison result, and obtain the adjusted reserved threads for the next cycle .

The technical solution of the present invention also provides a device for adjusting the number of reserved threads in the thread pool, including:

The non-task operation frequency statistics unit is used for the frequency of non-task operations in the periodical statistics cycle;

The number of reserved threads in the next cycle is determined by a unit, which is used to determine the number of reserved threads in the thread pool of the next cycle according to the frequency of non-task operations in this cycle determined by the non-task operation frequency statistics unit;

The next cycle reserved thread adjustment unit is used to compare the number of reserved threads in the thread pool of the next cycle determined by the next cycle reserved thread quantity determination unit with the number of reserved threads in the current thread pool, and adjust the current thread pool according to the comparison result The reserved threads in get the number-adjusted reserved threads for the next cycle.

The technical solution of the present invention also provides a device for task execution, including:

The task management module is used to judge whether there are idle reserved threads in the current thread pool after receiving the task; if so, assign the task to one of the idle reserved threads for execution; otherwise:

Determine whether the task queue of the current thread pool has remaining space; if there is the remaining space, then store the task in the task queue; if there is no remaining space, create a set number of extended threads in the thread pool, and assigning the tasks to be executed in the task queue to the extended threads for execution;

The reserved thread adjustment module is used for periodically counting the frequency of non-task operations in the period; according to the frequency of non-task operations counted in this period, determine the number of reserved threads in the thread pool of the next cycle; the determined next The number of reserved threads in the periodic thread pool is compared with the number of reserved threads in the current thread pool, and the reserved threads in the current thread pool are adjusted according to the comparison result to obtain the adjusted reserved threads in the next cycle.

Preferably, the reserved thread adjustment module specifically includes:

The non-task operation frequency statistics unit is used for the frequency of non-task operations in the periodical statistics cycle;

The unit for determining the number of reserved threads in the next cycle is used to determine the number of reserved threads in the thread pool of the next cycle according to the frequency of non-task operations in the current cycle determined by the non-task operation frequency statistics unit and according to the set rules.

The next cycle reserved thread adjustment unit is used to compare the number of reserved threads in the thread pool of the next cycle determined by the next cycle reserved thread quantity determination unit with the number of reserved threads in the current thread pool, and adjust the current thread pool according to the comparison result The reserved threads in get the number-adjusted reserved threads for the next cycle.

The method and device of the scheme of the present invention realize the automatic adjustment of the reserved threads of the thread pool in the process of executing tasks, and use the automatically adjusted reserved threads of the thread pool to execute tasks with variable numbers, reducing the system resources of non-task operations in the thread pool working process Consumption, to ensure the response speed of the task, but also reduce the occupied system resources.

Description of drawings

Fig. 1 is a flowchart of a method for adjusting the number of reserved threads in a thread pool according to an embodiment of the present invention;

FIG. 2a is a fluctuation diagram of the number of tasks within a cycle according to an embodiment of the present invention;

Figure 2b is a block diagram of the internal structure of the device for adjusting the number of reserved threads in the thread pool according to an embodiment of the present invention;

3 is a flowchart of a method for performing tasks by periodically adjusting the number of reserved threads in a thread pool according to an embodiment of the present invention;

FIG. 4 is a block diagram of an internal structure of an apparatus for performing tasks by periodically adjusting the number of reserved threads in a thread pool according to an embodiment of the present invention.

Detailed ways

In order to make the object, technical solution and advantages of the present invention clearer, the present invention will be described in further detail below with reference to the accompanying drawings and preferred embodiments. However, it should be noted that many of the details listed in the specification are only for readers to have a thorough understanding of one or more aspects of the present invention, and these aspects of the present invention can be implemented even without these specific details.

As used herein, terms such as "module" and "system" are intended to include computer-related entities such as, but not limited to, hardware, firmware, a combination of hardware and software, software, or software in execution. For example, a module may be, but is not limited to being limited to being, a process running on a processor, a processor, an object, an executable, a thread of execution, a program, and/or a computer. For example, both an application running on a computing device and the computing device could be modules. One or more modules can reside within a process and/or thread of execution and a module can be localized on one computer and/or distributed between two or more computers.

The inventors of the present invention consider that although the change in the number of tasks is unpredictable, within a period of time, a large change in the number of tasks will cause a large change in the frequency of non-task operations in the working process of the thread pool. Therefore, in the process of executing tasks automatically adjust the number of reserved threads in the thread pool according to the statistics of the non-task operation frequency, so as to reduce the system resource consumption of the non-task operation of the thread pool and improve the response speed to the task. Among them, non-task operations include task queue operations and extended thread operations; task queue operations include operations of entering tasks into the task queue, and extended thread operations include operations of creating extended threads and destroying extended threads.

On the other hand, by using the method of automatically adjusting the reserved threads in the thread pool to execute tasks with varying numbers, the system resource consumption of non-task operations in the thread pool is reduced, and the response speed to tasks is improved.

Based on the above analysis, two aspects of the technical solution of the present invention are described next. One of the aspects is a method and device for automatically adjusting the number of reserved threads in the thread pool according to the frequency of non-task operations in the periodical statistical period; another aspect is the method and device for performing tasks with variable numbers by using the thread pool for periodically automatically adjusting the reserved threads. device. Wherein, the period is a preset period of time. The technical scheme of the present invention will be described in detail below in conjunction with the accompanying drawings.

Among them, according to the frequency of non-task operations in the periodic statistical period, the specific flow chart of the method for automatically adjusting the number of reserved threads in the thread pool is shown in Figure 1, and specifically includes the following steps:

S101: Initialize the thread pool.

Specifically, the software using the thread pool technology is started, a thread pool manager, a task interface, a task queue, and a certain number of reserved threads are created in the current thread pool, and the length of the task queue of the thread pool is set. For example, the number of reserved threads created is 2, and the task queue length is set to 50.

At the same time, the thread pool manager starts to monitor and count the frequency of non-task operations until the number of reserved threads is 0.

S102: The thread pool manager periodically counts the frequency of non-task operations within a period.

Specifically, at the beginning of each cycle, the frequency of non-task operations in this cycle is cleared to 0; in each cycle, the thread pool manager first assigns the tasks accepted by the task interface to idle reserved threads for execution. When the number of idle reserved threads is large, the number of idle reserved threads will gradually decrease. When the number of idle reserved threads is 0, the thread pool manager will add the tasks to be executed to the task queue in turn (that is, task queue operation); when the task queue is full, the thread pool manager will Execute the operation of creating an extended thread; when the number of tasks changes from large to small, the extended thread is idle, and the thread pool management executes the operation of destroying the extended thread; when the number of tasks remains relatively stable, there are few non-task operations; The frequency of non-task operations is counted.

For example, within a cycle, the number of tasks fluctuates as shown in Figure 2a. The abscissa is time, increasing at equal intervals from left to right, and the ordinate is the number of tasks, increasing at equal intervals from bottom to top; the number of tasks is relatively stable from the initial At 10, the rapid fluctuation becomes larger and relatively stable at 120, and then the fluctuation becomes smaller and relatively stable at 40, and the non-task operation frequency counted in this period is 8.

S103: Determine the number of reserved threads in the thread pool in the next cycle according to the frequency of non-task operations counted in this cycle.

Specifically, how to determine the number of reserved threads in the thread pool of the next cycle can adopt the following method: For example, compare the frequency of non-task operations in this cycle determined in step S102 with several frequency thresholds: The frequency threshold of the task operation frequency is determined to be less than the maximum frequency threshold among the frequency thresholds of the non-task operation frequency, and the number of reserved threads corresponding to the maximum frequency threshold is used as the number of reserved threads in the thread pool of the next cycle. number; otherwise, use the number of non-idle reserved threads in this cycle as the number of reserved threads in the thread pool for the next cycle.

Or, this cycle is decomposed into n sub-cycles, n is a natural number, and the non-task operation frequency of the current cycle is decomposed into n non-task operation sub-frequency statistics respectively in n sub-cycles; The frequency is compared with several frequency thresholds respectively: if there are frequency thresholds less than n said non-task operation sub-frequency, then determine the maximum frequency threshold in each frequency threshold less than n said non-task operation sub-frequency, and set The recommended number of reserved threads corresponding to the maximum frequency threshold is used as the number of reserved threads in the thread pool of the next cycle; otherwise, the number of non-idle reserved threads in this cycle is used as the number of reserved threads in the thread pool of the next cycle.

Wherein, each of the frequency thresholds and the corresponding recommended number of reserved threads are preset natural numbers.

S104: Compare the determined number of reserved threads in the thread pool of the next cycle with the number of reserved threads in the current thread pool, adjust the reserved threads in the current thread pool according to the comparison result, and obtain the adjusted number of threads in the next cycle Threads are reserved.

Specifically, the calculation step S103 determines the difference between the number of reserved threads in the thread pool of the next cycle minus the number of reserved threads in the current thread pool: if the calculated difference is greater than 0, then the thread pool manager is in the current thread pool. Create the same number of reserved threads as the difference in the pool; if the calculated difference is equal to 0, the reserved threads of the current thread pool remain unchanged; if the calculated difference is less than 0, the thread pool manager destroys the current The same number of idle reserved threads as the difference value in the thread pool; obtain the adjusted number of reserved threads in the next cycle.

The embodiment of the present invention provides a device for adjusting the number of reserved threads in the thread pool. The block diagram of the content structure is shown in Figure 2b, including:

The non-task operation frequency statistics unit 201 is configured to periodically count the frequency of non-task operations within a period. The non-task operation frequency statistics unit 201 specifically clears the non-task operation frequency of this cycle to 0 at the beginning of each cycle; in each cycle, when the current thread pool does not have idle reserved threads, then counts the number of operations performed in the task queue. Frequency; when the task queue is full, count the frequency of creating extended thread operations; when the number of tasks changes from large to small, count the frequency of executing extended thread operations; among them, task queue operations, create extended thread operations, and destroy extended threads Operations are all non-task operations.

The next cycle reserved thread number determination unit 202 is used to determine the number of reserved threads in the thread pool in the next cycle according to the frequency of non-task operations in the current cycle determined by the non-task operation frequency statistics unit 201 . The number of reserved threads determining unit 202 in the next cycle can specifically determine the number of reserved threads in the thread pool of the next cycle by using the following method: For example, decomposing this cycle into n sub-cycles, n being a natural number, the non-task operation of the current cycle The frequency is decomposed into n non-task operation sub-frequency statistics respectively in n sub-periods; the n non-task operation sub-frequency are compared with several frequency thresholds: if there is a frequency threshold less than n non-task operation sub-frequency, then Determine the maximum frequency threshold among the frequency thresholds less than n non-task operation sub-frequency, and use the recommended number of reserved threads corresponding to the maximum frequency threshold as the number of reserved threads in the thread pool of the next cycle; otherwise, the current cycle The number of non-idle reserved threads is used as the number of reserved threads in the thread pool for the next cycle.

Wherein, each of the frequency thresholds and the corresponding recommended number of reserved threads are preset natural numbers.

The next cycle reserved thread adjustment unit 203 is used to calculate the difference between the number of reserved threads in the thread pool of the next cycle determined by the next cycle reserved thread number determination unit 202 minus the number of reserved threads in the current thread pool. If the difference is greater than 0, create the same number of reserved threads as the difference in the current thread pool; if the calculated difference is equal to 0, the reserved threads of the current thread pool remain unchanged; if the calculated difference If it is less than 0, the number of idle reserved threads in the current thread pool equal to the difference is destroyed.

In addition, the specific flow chart of the method for executing tasks with varying numbers by periodically automatically adjusting the thread pool of reserved threads is shown in Figure 3, which specifically includes the following steps:

S301: Initialize the thread pool.

Specifically, the software using the thread pool technology is started, a thread pool manager, a task interface, a task queue, and a certain number of reserved threads are created in the current thread pool, and the length of the task queue is set.

S302: After receiving the task through the task interface, the thread pool manager judges whether there is an idle reserved thread in the current thread pool; if yes, execute step S303; otherwise, execute step S304.

S303: The thread pool manager assigns the task to one of the idle reserved threads for execution.

When the number of tasks is small and relatively stable, the automatically adjusted reserved thread is used to execute the task, and there is no need for task queue operations, creation of extended thread operations, and destruction of extended thread operations, which saves system resources consumed by non-task operations and ensures that tasks are guaranteed. Response speed; there is no need for redundant reserved threads, which reduces the occupation of system resources.

S304: The thread pool manager judges whether there is remaining space in the task queue; if there is remaining space, execute step S305; otherwise, execute step S306.

S305: The thread pool manager stores the tasks in the task queue.

When the number of tasks changes from large to small, the automatically adjusted reserved thread is used to execute tasks, without creating and destroying extended thread operations, only task queue operations are required, which saves system resources consumed by non-task operations and ensures the response speed to tasks.

S306: The thread pool manager creates a set number of extended threads in the current thread pool, and assigns the tasks to be executed in the task queue to the extended threads for execution.

When the number of tasks increases from small to large or the number of tasks is large and relatively stable, use the automatically adjusted reserved thread to execute tasks, reduce the probability of creating and destroying extended thread operations, and ensure the corresponding speed of tasks.

In addition, the thread pool manager monitors the state of the extended thread: if it detects that the extended thread has completed its task, it will mark the extended thread as idle, and destroy the extended thread that has been idle for a period of time; the undestroyed extended thread continues to perform tasks until the extended thread is extended. The number of threads is 0, and threads are reserved to continue executing tasks.

The thread pool manager monitors the status of the task queue. If the task queue is not empty: then judge whether the thread pool manager detects that the number of extended threads is 0: if the number of extended threads is 0, the task to be executed is removed from the task queue according to the first-in-first-out principle. The queue is allocated to the reserved thread for execution; otherwise, the task to be executed is allocated from the task queue to the extended thread for execution; until the task queue is empty.

The thread pool manager monitors the state of the reserved thread: if it detects that the reserved thread has completed its task, it will mark the reserved thread as idle; even if the reserved thread is idle for a period of time, it will not be destroyed, and the non-idle reserved thread will continue to perform tasks until it is not idle The number of reserved threads is 0.

In addition, the embodiment of the present invention also provides a device for executing tasks with variable numbers by periodically automatically adjusting the thread pool of reserved threads. The internal structure block diagram is shown in FIG. module 402;

Described task management module 401, after being used to receive task, judges whether there is idle reserved thread in the current thread pool; If yes, then this task is assigned to wherein one idle reserved thread to carry out; Otherwise: judge current thread pool Whether there is any remaining space in the task queue; if there is any remaining space, the task will be stored in the task queue; if there is no such remaining space, then a set number of extended threads will be created in the thread pool, and the task will be stored in the task queue. The to-be-executed tasks are respectively assigned to the extension threads for execution;

Wherein, the number of reserved threads in the thread pool is adjusted according to the reserved thread adjustment module 402: the reserved thread adjustment module 402 is used to periodically count the frequency of non-task operations in the cycle; Frequency, determine the number of reserved threads in the thread pool of the next cycle; compare the determined number of reserved threads in the thread pool of the next cycle with the number of reserved threads in the current thread pool, and adjust the current thread pool according to the comparison result The reserved threads in get the number-adjusted reserved threads for the next cycle.

Wherein, the reserved thread adjustment module 402 includes: the above-mentioned non-task operation frequency statistics unit 201 , the next cycle reserved thread number determination unit 202 and the next cycle reserved thread adjustment unit 203 .

Both the task management module 401 and the reserved thread adjustment module 402 mentioned above can be set in the thread pool manager, or the task management module 401 is set in the thread pool manager, and the reserved thread adjustment module 402 is set outside the thread pool manager.

The method and device of the scheme of the present invention realize the automatic adjustment of the reserved threads of the thread pool in the process of executing tasks, and use the automatically adjusted reserved threads of the thread pool to execute tasks with variable numbers, reducing the system resources of non-task operations in the thread pool working process Consumption, to ensure the response speed of the task, but also reduce the occupied system resources.

The above is only a preferred embodiment of the present invention, it should be pointed out that for those of ordinary skill in the art, without departing from the principle of the present invention, some improvements and modifications can also be made, and these improvements and modifications should also be It is regarded as the protection scope of the present invention.

Claims (10)

1. A method for adjusting the number of reserved threads in the thread pool, comprising: the frequency of non-task operations within a periodic statistical period; and According to the frequency of non-task operations counted in this period, determine the number of reserved threads in the thread pool for the next period; Compare the determined number of reserved threads in the thread pool for the next cycle with the number of reserved threads in the current thread pool, adjust the reserved threads in the current thread pool according to the comparison result, and obtain the adjusted reserved threads for the next cycle . 2 . The method according to claim 1 , wherein the non-task operation comprises: an extended thread operation; wherein the extended thread operation specifically comprises: operations of creating an extended thread and destroying an extended thread. 3. The method according to claim 2, wherein the non-task operation further comprises: a task queue operation; wherein the task queue operation is specifically an operation of storing a task in a task queue. 4. The method according to claim 2 or 3, wherein the frequency of non-task operations within the periodical statistical period specifically includes: At the beginning of each cycle, the frequency of non-task operations in this cycle is cleared to 0; During this period, count the frequency of non-task operations in the process of tasks whose execution quantity changes in the current thread pool. 5. The method according to claim 4, wherein, the number of reserved threads in the thread pool of the next cycle is determined according to the non-task operation frequency counted in this cycle, specifically comprising: Compare the frequency of non-task operations counted in the current period with several frequency thresholds: If there is a frequency threshold less than the frequency of the non-task operation, then determine the maximum frequency threshold less than the frequency thresholds of the non-task operation frequency, and use the suggested number of reserved threads corresponding to the maximum frequency threshold as the next cycle The number of threads reserved in the thread pool; Otherwise, use the number of non-idle reserved threads in this cycle as the number of reserved threads in the thread pool for the next cycle; Alternatively, the number of reserved threads in the thread pool of the next cycle is determined according to the frequency of non-task operations counted in this period, specifically including: The current cycle is decomposed into n sub-cycles, n is a natural number, and the non-task operation frequency counted in the current cycle is decomposed into n non-task operation sub-frequency statistics respectively in n sub-cycles; The operator sub-frequency is compared with several frequency thresholds respectively: If there are frequency thresholds less than n sub-frequency of the non-task operation, determine the maximum frequency threshold in each frequency threshold less than n sub-frequency of the non-task operation, and suggest the reserved thread corresponding to the maximum frequency threshold The number is used as the number of reserved threads in the thread pool for the next cycle; Otherwise, use the number of non-idle reserved threads in this cycle as the number of reserved threads in the thread pool for the next cycle; Wherein, each of the frequency thresholds and the corresponding recommended number of reserved threads are preset natural numbers. 6. The method according to claim 5, wherein, comparing the number of reserved threads in the thread pool of the next cycle determined with the number of reserved threads in the current thread pool, adjusting the number of threads in the current thread pool according to the comparison result The reserved threads of the next cycle are obtained after adjusting the number of reserved threads, including: Calculate the difference between the determined number of reserved threads in the thread pool of the next cycle and the number of reserved threads in the current thread pool; If the calculated difference is greater than 0, then create a number of reserved threads corresponding to the difference in the thread pool; The corresponding number of reserved threads are destroyed. 7. A task execution method, comprising: After the thread pool manager receives the task, it judges whether there is an idle reserved thread in the current thread pool; if so, assigns the task to one of the idle reserved threads for execution; otherwise: The thread pool manager judges whether the task queue of the current thread pool has remaining space; if there is remaining space, the thread pool manager stores the task in the task queue; if there is no remaining space, the thread pool manager Create a set number of extension threads in the thread pool, and assign tasks to be executed in the task queue to the extension threads for execution; Wherein, the number of reserved threads in the thread pool is adjusted according to the following method: The frequency of non-task operations in the periodic statistical period; According to the frequency of non-task operations counted in this period, determine the number of reserved threads in the thread pool for the next period; Compare the determined number of reserved threads in the thread pool for the next cycle with the number of reserved threads in the current thread pool, adjust the reserved threads in the current thread pool according to the comparison result, and obtain the adjusted reserved threads for the next cycle . 8. A device for adjusting the number of reserved threads in a thread pool, comprising: The non-task operation frequency statistics unit is used for the frequency of non-task operations in the periodical statistics cycle; The number of reserved threads in the next cycle is determined by a unit, which is used to determine the number of reserved threads in the thread pool of the next cycle according to the frequency of non-task operations in this cycle determined by the non-task operation frequency statistics unit; The next cycle reserved thread adjustment unit is used to compare the number of reserved threads in the thread pool of the next cycle determined by the next cycle reserved thread quantity determination unit with the number of reserved threads in the current thread pool, and adjust the current thread pool according to the comparison result The reserved threads in get the number-adjusted reserved threads for the next cycle. 9. A device for performing tasks, comprising: The task management module is used to judge whether there are idle reserved threads in the current thread pool after receiving the task; if so, assign the task to one of the idle reserved threads for execution; otherwise: Determine whether the task queue of the current thread pool has remaining space; if there is the remaining space, then store the task in the task queue; if there is no remaining space, create a set number of extended threads in the thread pool, and assigning the tasks to be executed in the task queue to the extended threads for execution; The reserved thread adjustment module is used for periodically counting the frequency of non-task operations in the period; according to the frequency of non-task operations counted in this period, determine the number of reserved threads in the thread pool of the next cycle; the determined next The number of reserved threads in the periodic thread pool is compared with the number of reserved threads in the current thread pool, and the reserved threads in the current thread pool are adjusted according to the comparison result to obtain the adjusted reserved threads in the next cycle. 10. The device according to claim 9, wherein the reserved thread adjustment module specifically comprises: The non-task operation frequency statistics unit is used for the frequency of non-task operations in the periodical statistics cycle; The unit for determining the number of reserved threads in the next cycle is used to determine the number of reserved threads in the thread pool of the next cycle according to the frequency of non-task operations in the current cycle determined by the non-task operation frequency statistics unit and according to the set rules. The next cycle reserved thread adjustment unit is used to compare the number of reserved threads in the thread pool of the next cycle determined by the next cycle reserved thread quantity determination unit with the number of reserved threads in the current thread pool, and adjust the current thread pool according to the comparison result The reserved threads in get the number-adjusted reserved threads for the next cycle.

Images