CN118519750A - Task processing method, device, computer equipment and storage medium - Google Patents

Abstract

The present application relates to the field of computer technology, and discloses a task processing method, apparatus, computer equipment and storage medium, including: if the target task is assigned to the task queue of the first thread in the thread pool, and the target task meets the decomposition condition, the target task is decomposed according to the decomposition strategy corresponding to the target task to obtain multiple subtasks; multiple threads in the thread pool are called to execute multiple subtasks respectively, wherein the multiple threads include the first thread; if the decomposition strategy includes an aggregation tag, the execution results of the multiple subtasks are aggregated. The method of the present application can realize the parallel execution of the target task by multiple threads in a computing-intensive task scenario by detailed decomposition of the target task, improve the processor utilization efficiency, and reduce the execution time of each task. Moreover, the decomposition conditions and decomposition strategies support customization, meet the needs of executing tasks in different scenarios, and expand the scope of application.

Description

Task processing method, device, computer equipment and storage medium

Technical Field

The present application relates to the field of computer technology, and in particular to a task processing method, apparatus, computer equipment and storage medium.

Background Art

In the related art, when using threads to execute tasks, the thread life cycle is usually managed. This thread pool management solution is to call an idle thread to process when a new task is received. If there is no idle thread at present, it will be placed in a waiting queue to wait for processing. However, the existing thread pool management solution has the following main problems:

1. A single task is processed by a single thread. If there are more idle threads than tasks, the idle threads cannot relieve the processing pressure of other threads, resulting in a waste of resources.

2. It is not suitable for computing-intensive tasks and its applicable scenarios are relatively limited.

Summary of the invention

In view of this, the present application provides a task processing method, apparatus, computer device and storage medium to solve the problem of resource waste when threads execute tasks.

In a first aspect, a task processing method is provided, comprising:

If the target task is assigned to the task queue of the first thread in the thread pool and the target task meets the decomposition condition, the target task is decomposed according to the decomposition strategy corresponding to the target task to obtain multiple subtasks;

Calling multiple threads in the thread pool to respectively execute multiple subtasks, wherein the multiple threads include a first thread;

If the decomposition strategy contains an aggregation tag, the execution results of multiple subtasks are aggregated.

Furthermore, multiple threads in the calling thread pool respectively execute multiple subtasks, including:

Calling the first thread to execute the first subtask, and deleting the second subtask from the task queue of the first thread;

If the number of the second threads in the idle state is greater than or equal to the number of the second subtasks, the second subtasks are evenly distributed to the task queues of the second threads in the idle state, and the second threads are called to execute the second subtasks;

The second thread is a thread in the thread pool other than the first thread, the first subtask is any subtask among the multiple subtasks, and the second subtask is a subtask among the multiple subtasks other than the first subtask.

Furthermore, multiple threads in the calling thread pool respectively execute multiple subtasks, including:

If the number of the second threads in the idle state is less than the number of the second subtasks, determining the priority of the second subtask;

Sort the second subtasks by priority to obtain the first order;

The second subtask is assigned to the task queue of the thread in the idle state in the thread pool according to the first sequence, and the threads in the idle state in the thread pool are called to execute the second subtask sequentially.

Furthermore, the task processing method also includes:

If the number of threads in the thread pool is less than the thread threshold of the thread pool, a temporary thread is created, wherein the threads in the thread pool include a first thread and a second thread;

The temporary line is called to execute the target task, the first subtask, or the second subtask.

Furthermore, the task processing method also includes:

If the duration of the temporary thread being in the idle state is greater than or equal to the first preset duration, the temporary thread is deleted.

Furthermore, the task processing method also includes:

If all threads in the thread pool are in working state, and the number of threads in the thread pool is greater than or equal to the thread threshold of the thread pool, the remaining working time of the threads in the thread pool is determined;

If the remaining working time of the threads in the thread pool is greater than the second preset time, the target task is refused to be executed or the target task is scheduled to other thread pools.

Furthermore, the task processing method also includes:

Obtain the business scenario of the target task;

Match decomposition strategies and decomposition conditions according to business scenarios;

The decomposition strategy includes at least one of the following: aggregation tags, trigger conditions and decomposition rules; the trigger conditions include: decomposing the target task before executing the target task, or decomposing the target task during the execution of the target task.

In a second aspect, a task processing device is provided, comprising:

A decomposition module is used for decomposing the target task according to the decomposition strategy corresponding to the target task to obtain multiple subtasks if the target task is assigned to the task queue of the first thread in the thread pool and the target task meets the decomposition condition;

An execution module, used for calling multiple threads in the thread pool to respectively execute multiple subtasks, wherein the multiple threads include a first thread;

The aggregation module is used to aggregate the execution results of multiple subtasks if the decomposition strategy contains an aggregation tag.

Further, the execution module is specifically used to call the first thread to execute the first subtask, and delete the second subtask from the task queue of the first thread; if the number of second threads in an idle state is greater than or equal to the number of second subtasks, evenly distribute the second subtasks to the task queues of the second threads in an idle state, and call the second thread to execute the second subtask;

The second thread is a thread in the thread pool other than the first thread, the first subtask is any subtask among the multiple subtasks, and the second subtask is a subtask among the multiple subtasks other than the first subtask.

Furthermore, the task processing device also includes:

A first determining module, configured to determine the priority of the second subtask if the number of the second threads in an idle state is less than the number of the second subtasks;

A sorting module, used for sorting the second subtasks according to the priority to obtain a first order;

The execution module is specifically used to distribute the second subtask to the task queue of the thread in the idle state in the thread pool according to the first order, and call the threads in the idle state in the thread pool to execute the second subtask sequentially.

Furthermore, the task processing device also includes:

A thread management module, used for creating a temporary thread if the number of threads in the thread pool is less than a thread threshold of the thread pool, wherein the threads in the thread pool include a first thread and a second thread;

The execution module is specifically used to call the temporary line to execute the target task, the first subtask or the second subtask.

Furthermore, the thread management module is further configured to delete the temporary thread if the duration for which the temporary thread is in an idle state is greater than or equal to a first preset duration.

Furthermore, the task processing device also includes:

The second determination module is used to determine the remaining working time of the threads in the thread pool if all the threads in the thread pool are in a working state and the number of threads in the thread pool is greater than or equal to the thread threshold of the thread pool;

The execution module is further configured to refuse to execute the target task if the remaining working time of the threads in the thread pool is greater than a second preset time;

or,

The scheduling module is used to schedule the target task to other thread pools if the remaining working time of the threads in the thread pool is greater than the second preset time.

Furthermore, the task processing device also includes:

The acquisition module is used to obtain the business scenario of the target task;

A matching module is used to match decomposition strategies and decomposition conditions according to business scenarios;

Among them, the decomposition strategy includes at least one of the following: aggregation tags, trigger conditions and decomposition rules; the trigger conditions include: decomposing the target task before executing the target task, or decomposing the target task during the execution of the target task.

In a third aspect, a computer device is provided, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the steps of the above-mentioned task processing method when executing the computer program.

In a fourth aspect, a computer-readable storage medium is provided, wherein the computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the steps of the above-mentioned task processing method are implemented.

In the scheme implemented by the above-mentioned task processing method, device, computer equipment and storage medium, if it is detected that the target task is assigned to the task queue of the first thread in the thread pool, that is, the processor is about to call the first thread to execute the target task. At this time, if the target task meets the decomposition condition, the larger target task is decomposed into smaller subtasks before or during the execution of the target task, so that the target task is no longer executed by only one thread, but can be decomposed and executed by multiple threads. When there is an aggregation tag in the decomposition strategy corresponding to the target task, the execution results of multiple subtasks are aggregated to obtain the execution result of the target task. Through the above-mentioned technical scheme, on the one hand, in a computing-intensive task scenario, by refining the decomposition of the target task, the task can be split as much as possible, and multiple threads can be realized to execute the target task in parallel, which greatly improves the processor utilization efficiency and reduces the execution time of each task; on the other hand, the decomposition conditions and decomposition strategies support user customization, support the needs of executing tasks in a variety of different scenarios, and expand the application scope of the task processing scheme.

The above description is only an overview of the technical solution of the present application. In order to more clearly understand the technical means of the present application, it can be implemented in accordance with the contents of the specification. In order to make the above and other purposes, features and advantages of the present application more obvious and easy to understand, the specific implementation methods of the present application are listed below.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings required for use in the description of the embodiments of the present application will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative labor.

FIG1 is a flowchart of a task processing method in the present application;

FIG2 is a second flow chart of the task processing method in the present application;

FIG3 is a third flowchart of the task processing method in the present application;

FIG4 is a fourth flowchart of the task processing method in the present application;

FIG5 is a schematic diagram of the structure of a task processing device in the present application;

FIG. 6 is a schematic diagram of the structure of a computer device in the present application.

DETAILED DESCRIPTION

The following will be combined with the drawings in the embodiments of the present application to clearly and completely describe the technical solutions in the embodiments of the present application. Obviously, the described embodiments are part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of this application.

Please refer to FIG. 1 , which is a flowchart of a task processing method provided in an embodiment of the present application, comprising the following steps:

Step 101: if the target task is assigned to the task queue of the first thread in the thread pool and the target task meets the decomposition condition, the target task is decomposed according to the decomposition strategy corresponding to the target task to obtain multiple subtasks;

In this embodiment, after the target task is submitted to the thread pool, the thread pool determines whether there is a thread in an idle state. If not, the target task is assigned to the waiting task queue to be acquired and executed by the thread waiting for the idle state. If it exists, the thread in the idle state is used as the first thread that can execute the target task. After the target task is assigned to the task queue of the first thread in the thread pool, it is determined whether the target task meets the decomposition condition. If the target task meets the decomposition condition, that is, the target task can be decomposed, the target task is decomposed into multiple subtasks according to the corresponding decomposition strategy, so that different threads can be used to execute them respectively, thereby realizing parallel processing of multiple subtasks, reducing the execution time of the target task, and realizing more efficient thread pool management.

It can be understood that, before step 101, that is, if the target task meets the decomposition condition, the target task is decomposed according to the decomposition strategy corresponding to the target task to obtain multiple subtasks, the task processing method further includes:

Step 201, obtaining the business scenario of the target task;

Step 202: Match the decomposition strategy and decomposition conditions according to the business scenario.

Among them, the decomposition condition can be whether the resource usage of the target task is greater than the preset usage, or whether the business scenario to which the target task belongs is a specified scenario or whether there is an associated decomposition strategy, etc., which will not be listed one by one in the embodiments of the present application. The decomposition strategy includes: aggregation tags, trigger conditions and/or decomposition rules. The aggregation tag is used to mark whether the decomposed subtasks need to be aggregated. The trigger condition includes decomposing the target task before executing the target task, or decomposing the target task during the execution of the target task. The decomposition rule can be divided according to the proportion of resource usage of the target task, divided according to the number of threads in the idle state of the thread pool, etc., which will not be listed one by one in the embodiments of the present application.

In this embodiment, the decomposition conditions and decomposition strategies can be reasonably set by the user according to the actual business scenario, or the pre-set corresponding relationship or model can be used to match the required decomposition strategy and decomposition conditions with the business scenario of the target task. This realizes the personalized configuration of the decomposition conditions and decomposition strategies, makes the decomposition method of the target task more flexible, improves the detailed decomposition effect of the target task, increases the probability of parallel execution of threads, and can support the needs of executing tasks in a variety of different scenarios, which is conducive to expanding the application scope of the task processing solution.

Step 102, calling multiple threads in the thread pool to respectively execute multiple subtasks;

The multiple threads in the thread pool include a first thread.

In this embodiment, after the target task is decomposed into multiple subtasks, multiple threads in the thread pool are used to execute the multiple subtasks respectively, so that the target task is no longer executed by only one thread, but can be decomposed and executed by multiple threads, thereby realizing multiple threads executing the target task in parallel, greatly improving the processor utilization efficiency and reducing the execution time of each task.

It is understandable that if the target task does not meet the decomposition condition, no decomposition process is performed, and the first thread is directly called to execute the target task. The technical solution eliminated in this embodiment not only supports the execution of decomposable tasks, but also supports the execution of indecomposable tasks, and can ensure the efficient execution of indecomposable tasks. Users only need to pay attention to the task logic, without paying attention to the internal principles of the thread pool, which is conducive to improving development efficiency and reducing development costs.

In a specific application scenario, as shown in FIG2 , step 102, that is, calling multiple threads in the thread pool to respectively execute multiple subtasks, specifically includes the following steps:

Step 102-1, calling the first thread to execute the first subtask, and deleting the second subtask from the task queue of the first thread;

Step 102-2: If the number of the second threads in the idle state is greater than or equal to the number of the second subtasks, then the process goes to step 102-3; if not, then the process goes to step 102-4;

The second thread is a thread in the thread pool other than the first thread, the first subtask is any subtask among the multiple subtasks, and the second subtask is a subtask among the multiple subtasks other than the first subtask.

Step 102-3, evenly distribute the second subtask to the task queue of the second thread, and call the second thread to execute the second subtask;

In this embodiment, the first thread to which the target task has been assigned is used to execute any subtask (first subtask) among the multiple subtasks, and the subtasks (second subtasks) other than the first subtask among the multiple subtasks are deleted from the first thread, so as to facilitate the allocation of new threads again. If the number of second threads in the thread pool that are in an idle state is greater than or equal to the number of second subtasks, it means that the thread pool has enough idle threads to execute the second subtask. At this time, the second subtask is evenly added to the task queue of the second thread, and at least one second thread in an idle state is called to execute at least one second subtask respectively. Thus, the processor only retains one subtask to be executed by the first thread, and the other subtasks are executed by other second threads in the thread pool, so that the target task is no longer executed by only one thread, but can be decomposed and executed by multiple threads. Thereby, multiple threads are implemented to execute the target task in parallel, which greatly improves the processor utilization efficiency, reduces the execution time of each task, effectively improves the execution efficiency of the task, and ensures the timeliness of the target task, especially in the case of computationally intensive tasks. Moreover, since the second subtask is evenly distributed, the thread synchronization overhead when multiple threads obtain the same subtask can be avoided, which is conducive to reducing unnecessary resource consumption.

Step 102-4, determining the priority of the second subtask;

Specifically, the priority of the second subtask can be determined according to the attribute information of the second subtask. The attribute information includes at least one of the following: estimated time, priority label, and task category. For example, the greater the estimated time, the higher the priority, or the priority of the second subtask belonging to the first category is higher than the priority of the second subtask belonging to the second category, etc.

Step 102-5, sorting the second subtasks according to the priority to obtain a first order;

Step 102-6, assigning the second subtask to the task queue of the thread in the idle state in the thread pool according to the first order, and calling the threads in the idle state in the thread pool to execute the second subtask sequentially.

In this embodiment, if the number of second threads in the thread pool that are in an idle state is greater than or equal to the number of second subtasks, it means that the second threads in the idle state cannot support the parallel execution of the second subtasks. At this time, the priority of each second subtask is determined, and the second subtasks are sorted according to the priority. The second subtasks are assigned to the task queues of the threads in the thread pool that are in an idle state one by one according to the first order of the second subtasks, and the threads in the thread pool that are in an idle state are called to execute the second subtasks in sequence. Not only is the thread synchronization overhead when multiple threads obtain the same subtask avoided, but the thread that first executes the subtask can continue to execute other subtasks, thereby using as many threads as possible to execute the split subtasks, while reducing the idle rate of threads in the thread pool, reducing the execution time of each subtask.

It is understandable that the thread in the thread pool in an idle state can be the first thread or the second thread. If there is still an unexecuted second subtask, and the first thread has finished executing the first subtask and resumed the idle state, the idle first thread can be used to execute the remaining unexecuted second subtask. Similarly, after the second thread has finished executing the second subtask and resumed the idle state, it can continue to obtain and execute the remaining unexecuted second subtask.

Step 103: If the decomposition strategy includes an aggregation tag, aggregation processing is performed on the execution results of the multiple subtasks.

In this embodiment, when an aggregation tag exists in the decomposition strategy corresponding to the target task, it indicates that the execution results of multiple subtasks need to be coordinated. Then, after the execution of multiple subtasks is completed, the execution results of the multiple subtasks are aggregated to determine the execution result of the target task, and the execution result of the target task is output. Thus, on the basis of completing the execution of the target task, the integrity of the execution result is guaranteed, saving the user the time of viewing the execution results of different subtasks separately, allowing the user to intuitively understand the result of the entire target task, and ensuring the convenience of outputting the execution result.

In some embodiments of the present application, as shown in FIG3 , a specific entity alignment solution is provided, and the task processing method further includes the following steps:

Step 301, if the number of threads in the thread pool is less than the thread threshold of the thread pool, create a temporary thread;

The threads in the thread pool include a first thread and a second thread. A temporary thread refers to a non-natural core thread in the thread pool that can be recycled.

Step 302, calling a temporary line to execute the target task, the first subtask or the second subtask;

In this embodiment, if the number of threads in the thread pool is less than the thread threshold of the thread pool, that is, the number of threads owned by the current thread pool has not reached the maximum number of threads allowed by the thread pool (thread threshold). At this time, some temporary threads can be created to use the temporary threads as the first thread or the second thread to execute the target task, the first subtask or the second subtask. This enables the thread pool to provide more idle threads, process the target task in a timely manner, optimize the thread management of the thread pool, ensure the independent operation of multiple tasks, and achieve fast and efficient target task processing.

It is worth mentioning that the triggering conditions for creating temporary threads also include: when the number of target tasks or multiple subtasks is greater than the number of core threads of the thread pool, a temporary thread is created; or when the number of target tasks or multiple subtasks is greater than the sum of the number of core threads and the number of specified task queues, the thread pool believes that the existing core threads can process the tasks in time, and this is to create a new temporary thread.

Step 303: If the duration of the temporary thread being in the idle state is greater than or equal to the first preset duration, the temporary thread is deleted.

In this embodiment, if the duration of the temporary thread being in the idle state is greater than or equal to the first preset duration, indicating that the temporary thread has not been used for a long time, the temporary thread is promptly recycled to release the resources occupied by it, thereby preventing thread resource waste.

In some embodiments of the present application, as shown in FIG4 , a specific entity alignment solution is provided, and the task processing method further includes the following steps:

Step 401, if all threads in the thread pool are in working state, and the number of threads in the thread pool is greater than or equal to the thread threshold of the thread pool, determine the remaining working time of the threads in the thread pool;

Step 402: If the remaining working time of the threads in the thread pool is greater than the second preset time, the target task is refused to be executed or the target task is scheduled to other thread pools.

In this embodiment, when all threads in the thread pool are in working state, that is, there is no idle thread to execute the current target task, and the number of threads in the thread pool is greater than or equal to the thread threshold of the thread pool, that is, the thread pool has no space to create new threads, at this time, the remaining working time of each thread in the thread pool is determined. If the remaining working time of each thread in the thread pool is greater than the second preset time, it means that no idle thread will be released in a short time to execute the current target task, then the target task is refused to be executed, and the user is prompted that the target task execution fails, so that the user can take timely response remedial measures; or the target task is scheduled to other thread pools for other thread pools to process the target task, so as to ensure that the target task can be executed smoothly.

In a specific embodiment, a task processing method is provided, which specifically includes:

1. Create a thread pool or use an existing thread pool and set relevant parameters, including: initial number of core threads, maximum number of threads (thread threshold), waiting queue, rejection policy, idle thread survival time (first preset duration), thread factory, etc.

2. Create decomposable tasks or ordinary tasks (non-decomposable tasks) according to user needs. Decomposable tasks can implement decomposition logic and task execution logic, while ordinary tasks only need to implement execution logic.

3. Submit the target task to the thread pool.

4. The thread pool determines whether there is an idle thread at present. If so, the idle thread is used directly to execute the target task.

Specifically, the idle thread obtains the target task and starts to execute it, and determines whether the target task is a decomposable task, that is, whether the target task has a decomposition strategy before executing the decomposition task and meets the decomposition task conditions.

If it is a decomposable task, the decomposition task process is executed, the N decomposed tasks are encapsulated into N new subtasks, one subtask is left to be executed by the current thread, and the other decomposed subtasks are added to the decomposition task queue; the tasks in the decomposition queue are executed by other threads; it is determined whether the execution results of the decomposed subtasks need to be aggregated. If so, wait for other threads to complete the execution of the decomposed subtasks and then aggregate the results; if not, the thread can continue to obtain other decomposed subtasks from the decomposition task queue and execute them.

If it is a common task, the idle thread is directly used to execute the common task.

After the execution is completed, determine whether there are any tasks in the waiting task queue. If so, get a task from it and execute it.

5. If there is no idle thread, put the target task into the waiting task queue of the thread pool.

6. Determine whether the waiting task queue is full. If not, queue the target task and wait for other idle threads to obtain and execute it.

7. If the waiting task queue is full, determine whether the current number of threads is less than the maximum number of threads. If it is less, create a new thread through the thread creation factory to execute the task. After the task is completed, the newly created thread becomes an idle thread and starts waiting for new tasks to be issued. If the idle thread survival time is exceeded, it will be destroyed.

8. If it is determined that the current number of threads has reached the maximum number of threads, the target task is dispatched to the rejection task module, and the rejection task module executes the corresponding rejection strategy to reject the target task.

In this embodiment, on the one hand, in the scenario of computationally intensive tasks, tasks are supported to be decomposed according to a certain strategy. By decomposing the tasks in detail, tasks are split as much as possible, and large tasks are decomposed into small tasks. Tasks are no longer executed by only one thread, but can be decomposed and executed by multiple threads, allowing more threads to execute the split small tasks, improving CPU usage efficiency and reducing the execution time of each task. On the other hand, the strategy for decomposing tasks supports user customization, allowing users to customize the decomposition strategy according to actual scenarios, and supports decomposing tasks during task execution. It has a more flexible decomposition task strategy, which can decompose tasks to the greatest extent, increase the probability of other threads helping to execute, and support more usage scenarios. On the other hand, it has the function of executing decomposable tasks and the function of single tasks at the same time, can support the needs of executing tasks in different scenarios, has versatility, and users do not need to pay attention to its internal logic and the internal principles of the thread pool, improves development efficiency, and reduces development costs.

It should be understood that the size of the serial numbers of the steps in the above embodiments does not mean the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present application.

In one embodiment, a task processing device is provided, which corresponds to the task processing method in the above embodiment. As shown in FIG5 , the task processing device includes a decomposition module 501, an execution module 502, and an aggregation module 503. Each functional module is described in detail as follows:

A decomposition module 501 is used for decomposing the target task according to the decomposition strategy corresponding to the target task to obtain multiple subtasks if the target task is assigned to the task queue of the first thread in the thread pool and the target task meets the decomposition condition;

An execution module 502 is used to call multiple threads in a thread pool to respectively execute multiple subtasks, wherein the multiple threads include a first thread;

The aggregation module 503 is used to aggregate the execution results of multiple subtasks if the decomposition strategy includes an aggregation tag.

The present application provides a task processing device. If it is detected that the target task is assigned to the task queue of the first thread in the thread pool, that is, the processor is about to call the first thread to execute the target task. At this time, if the target task meets the decomposition condition, the larger target task is decomposed into smaller subtasks before or during the execution of the target task, so that the target task is no longer executed by only one thread, but can be decomposed and executed by multiple threads. When there is an aggregation tag in the decomposition strategy corresponding to the target task, the execution results of multiple subtasks are aggregated to obtain the execution result of the target task. Through the above technical solution, on the one hand, in a computationally intensive task scenario, by detailed decomposition of the target task, the task can be split as much as possible, and multiple threads can be used to execute the target task in parallel, which greatly improves the processor utilization efficiency and reduces the execution time of each task; on the other hand, the decomposition conditions and decomposition strategies support user customization, support the needs of executing tasks in a variety of different scenarios, and expand the application scope of the task processing solution.

In one embodiment, the execution module 502 is specifically configured to call the first thread to execute the first subtask, and delete the second subtask from the task queue of the first thread; if the number of the second threads in the idle state is greater than or equal to the number of the second subtasks, evenly distribute the second subtasks to the task queues of the second threads in the idle state, and call the second thread to execute the second subtask;

The second thread is a thread in the thread pool other than the first thread, the first subtask is any subtask among the multiple subtasks, and the second subtask is a subtask among the multiple subtasks other than the first subtask.

In one embodiment, the task processing device further includes: a first determination module (not shown in the figure) and a sorting module (not shown in the figure).

Specifically, the first determination module is used to determine the priority of the second subtask if the number of the second threads in the idle state is less than the number of the second subtasks;

A sorting module, used for sorting the second subtasks according to the priority to obtain a first order;

The execution module 502 is specifically configured to assign the second subtask to the task queue of the thread in the idle state in the thread pool according to the first sequence, and call the threads in the idle state in the thread pool to execute the second subtask sequentially.

In one embodiment, the task processing device further includes: a thread management module (not shown in the figure).

Specifically, the thread management module is used to create a temporary thread if the number of threads in the thread pool is less than the thread threshold of the thread pool, wherein the threads in the thread pool include a first thread and a second thread;

The execution module 502 is specifically used to call the temporary line to execute the target task, the first subtask or the second subtask.

In one embodiment, the thread management module is further configured to delete the temporary thread if the duration for which the temporary thread is in an idle state is greater than or equal to a first preset duration.

In one embodiment, the task processing device further includes: a first determination module (not shown in the figure) and a scheduling module (not shown in the figure).

Specifically, the second determination module is used to determine the remaining working time of the threads in the thread pool if all threads in the thread pool are in a working state and the number of threads in the thread pool is greater than or equal to the thread threshold of the thread pool;

The execution module 502 is also used to refuse to execute the target task if the remaining working time of the threads in the thread pool is greater than the second preset time; or, the scheduling module is used to schedule the target task to other thread pools if the remaining working time of the threads in the thread pool is greater than the second preset time.

In one embodiment, the task processing device further includes: an acquisition module (not shown in the figure) and a matching module (not shown in the figure).

Specifically, the acquisition module is used to obtain the business scenario of the target task;

A matching module is used to match decomposition strategies and decomposition conditions according to business scenarios;

Among them, the decomposition strategy includes at least one of the following: aggregation tags, trigger conditions and decomposition rules; the trigger conditions include: decomposing the target task before executing the target task, or decomposing the target task during the execution of the target task.

For the specific definition of the task processing device, please refer to the definition of the task processing method above, which will not be repeated here. Each module in the above-mentioned task processing device can be implemented in whole or in part by software, hardware and a combination thereof. The above-mentioned modules can be embedded in or independent of the processor in the computer device in the form of hardware, or can be stored in the memory of the computer device in the form of software, so that the processor can call and execute the operations corresponding to the above modules.

In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the computer program implements functions or steps of a task processing method when executed by the processor.

In one embodiment, a computer device is provided, which can be a client, and its internal structure diagram is shown in Figure 6. The computer device includes a processor, a memory, a network interface, a display screen and an input device connected through a system bus. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of the operating system and the computer program in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external server through a network connection. When the processor executes the computer program, the following steps are implemented: if the target task is assigned to the task queue of the first thread in the thread pool, and the target task meets the decomposition condition, the target task is decomposed according to the decomposition strategy corresponding to the target task to obtain multiple subtasks; multiple threads in the thread pool are called to execute multiple subtasks respectively, wherein the multiple threads include the first thread; if the decomposition strategy contains an aggregation tag, the execution results of the multiple subtasks are aggregated.

In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored. When the computer program is executed by a processor, the following steps are implemented: if a target task is assigned to a task queue of a first thread in a thread pool, and the target task meets a decomposition condition, the target task is decomposed according to a decomposition strategy corresponding to the target task to obtain a plurality of subtasks; a plurality of threads in the thread pool are called to respectively execute the plurality of subtasks, wherein the plurality of threads include the first thread; if the decomposition strategy includes an aggregation tag, the execution results of the plurality of subtasks are aggregated.

It should be noted that the above functions or steps that can be implemented by the computer-readable storage medium or computer device can refer to the relevant description of the task processing method in the aforementioned method embodiment. In order to avoid repetition, they will not be described one by one here.

Those skilled in the art can understand that all or part of the processes in the above-mentioned embodiment methods can be completed by instructing the relevant hardware through a computer program, and the computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to memory, storage, database or other media used in the embodiments provided in this application can include non-volatile and/or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM) or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. As an illustration and not limitation, RAM is available in many forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link (Synchlink) DRAM (SLDRAM), memory bus (Rambus) direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM).

Those skilled in the art can clearly understand that for the convenience and simplicity of description, only the division of the above-mentioned functional units and modules is used as an example. In actual applications, the above-mentioned functions can be distributed and completed by different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.

The embodiments described above are only used to illustrate the technical solutions of the present invention rather than to limit the same. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein; and these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be included in the protection scope of the present invention.

Claims (10)

1. A method of task processing, comprising:

If the target task is distributed to a task queue of a first thread in a thread pool and the target task meets a decomposition condition, decomposing the target task according to a decomposition strategy corresponding to the target task to obtain a plurality of subtasks;

invoking a plurality of threads in the thread pool to respectively execute the plurality of subtasks, wherein the plurality of threads comprise the first thread;

And if the decomposition strategy comprises an aggregation label, performing aggregation processing on the execution results of the plurality of subtasks.

2. The task processing method according to claim 1, wherein the invoking the plurality of threads in the thread pool to execute the plurality of subtasks, respectively, comprises:

Invoking the first thread Cheng Zhihang first subtask and deleting a second subtask from the first thread's task queue;

If the number of the second threads in the idle state is greater than or equal to the number of the second subtasks, the second subtasks are evenly distributed to a task queue of the second threads in the idle state, and the second threads are called to execute the second subtasks;

The second thread is a thread in the thread pool except for the first thread, the first subtask is any one of the plurality of subtasks, and the second subtask is a subtask in the plurality of subtasks except for the first subtask.

3. The task processing method according to claim 2, wherein the invoking the plurality of threads in the thread pool to execute the plurality of subtasks, respectively, includes:

If the number of the second threads in the idle state is smaller than the number of the second subtasks, determining the priority of the second subtasks;

sequencing the second subtasks according to the priority to obtain a first sequence;

and distributing the second subtasks to task queues of the threads in the idle state in the thread pool according to the first sequence, and calling the threads in the idle state in the thread pool to execute the second subtasks in sequence.

4. The task processing method according to claim 2, characterized in that the method further comprises:

if the number of threads in the thread pool is smaller than the thread threshold of the thread pool, creating temporary threads, wherein the threads in the thread pool comprise the first thread and the second thread;

and calling the temporary line to execute the target task, the first subtask or the second subtask.

5. The task processing method according to claim 4, characterized in that the method further comprises:

And deleting the temporary thread if the time length of the temporary thread in the idle state is greater than or equal to a first preset time length.

6. A task processing method according to any one of claims 1 to 5, characterized in that the method further comprises:

if the threads in the thread pool are in a working state and the number of threads in the thread pool is larger than or equal to the thread threshold of the thread pool, determining the residual working time length of the threads in the thread pool;

and if the residual working time length of the threads in the thread pool is greater than the second preset time length, refusing to execute the target task or scheduling the target task to other thread pools.

7. A task processing method according to any one of claims 1 to 5, characterized in that the method further comprises:

acquiring a service scene of the target task;

Matching the decomposition strategy and the decomposition conditions according to the service scene;

Wherein the decomposition policy comprises at least one of: the aggregation tag, the triggering condition and the decomposition rule, wherein the triggering condition comprises: and decomposing the target task before executing the target task, or decomposing the target task in the process of executing the target task.

8. A task processing device, comprising:

The decomposing module is used for decomposing the target task according to a decomposing strategy corresponding to the target task to obtain a plurality of subtasks if the target task is distributed to a task queue of a first thread in the thread pool and the target task meets the decomposing condition;

an execution module, configured to invoke a plurality of threads in the thread pool to execute the plurality of subtasks respectively, where the plurality of threads includes the first thread;

and the aggregation module is used for carrying out aggregation processing on the execution results of the plurality of subtasks if the decomposition strategy comprises an aggregation label.

9. Computer device comprising a memory, a processor and a computer program stored in the memory and executable on the processor, characterized in that the processor implements the steps of the task processing method according to any of claims 1 to 7 when the computer program is executed.

10. A computer-readable storage medium storing a computer program, characterized in that the computer program when executed by a processor implements the steps of the task processing method according to any one of claims 1 to 7.