Account checking task scheduling management method and system based on dynamic priority

Abstract

The invention discloses an account checking task scheduling management method and system based on a dynamic priority, and relates to the technical field of task scheduling management, and the method comprises the steps: aggregating a plurality of original account checking tasks according to a task dependence topology; setting a plurality of basic priorities of the plurality of original account checking tasks; outputting a plurality of dynamic priorities; performing hierarchical correction connection of the hierarchical task tree to obtain a target correction task tree; segmenting the target correction task tree; analyzing time sequence scheduling of the Q task execution containers, and outputting an elastic rotation container scheduling chain; and performing dynamic scheduling and account checking. The technical problems that in the prior art, account checking task scheduling lacks dynamic priority consideration, task execution efficiency is low, resource allocation is unreasonable, account checking work consumes long time, and resource waste is serious are solved, dynamic and efficient scheduling of the account checking tasks based on the priority is achieved, the task execution efficiency is improved, and user experience is improved. And the technical effect of resource allocation is optimized.

Description

Technical Field

[0001] The present invention relates to the technical field of task scheduling management, and in particular to a method and system for scheduling and managing reconciliation tasks based on dynamic priorities. Background Art

[0002] In many fields, such as finance and e-commerce, reconciliation tasks are a key link in ensuring the accuracy of funds and business data. As the scale of business continues to expand, the number of original reconciliation tasks has increased dramatically and the complexity has continued to increase. Traditional reconciliation task scheduling and management methods mostly use fixed priority or simple sequential execution methods. They are unable to dynamically adjust the execution order based on the timeliness requirements, amount, task type, etc. of the task, which can easily lead to delays in urgent and important tasks. At the same time, resources are unevenly allocated, resulting in low task execution efficiency and serious waste of system resources. In addition, existing solutions are difficult to effectively deal with the complex dependencies between tasks and the dynamic changes in the execution environment, and cannot meet the growing needs of reconciliation business.

[0003] The existing technology has technical problems such as lack of dynamic priority consideration in reconciliation task scheduling, low task execution efficiency, and unreasonable resource allocation, which leads to time-consuming reconciliation work and serious waste of resources. Summary of the Invention

[0004] The present application provides a reconciliation task scheduling management method and system based on dynamic priority, which is used to solve the technical problems in the existing technology that reconciliation task scheduling lacks dynamic priority considerations, task execution efficiency is low, and resource allocation is unreasonable, resulting in time-consuming reconciliation work and serious waste of resources.

[0005] In view of the above problems, the present application provides a reconciliation task scheduling management method and system based on dynamic priority.

[0006] A first aspect of the present application provides a method for scheduling and managing reconciliation tasks based on dynamic priorities, the method comprising: Aggregate multiple original reconciliation tasks according to the task dependency topology to obtain H hierarchical task trees; reversely set multiple basic priorities of the multiple original reconciliation tasks from the H hierarchical task trees; perform task priority evaluation based on the task attributes of the multiple original reconciliation tasks, and output multiple dynamic priorities; perform hierarchical correction and connection of the H hierarchical task trees according to the priority difference between the multiple basic priorities and the multiple dynamic priorities to obtain a target correction task tree; divide the target correction task tree into Q container-level task sets of Q task execution containers according to container efficiency; analyze the timing scheduling of the Q task execution containers based on the execution progress of the Q container-level task sets in the target correction task tree, and output an elastic rotation container scheduling chain; based on the elastic rotation container scheduling chain, schedule the Q task execution containers to perform dynamic scheduling and reconciliation of the Q container-level task sets along the target correction task tree in descending order of priority.

[0007] A second aspect of the present application provides a dynamic priority-based reconciliation task scheduling and management system, the system comprising: A hierarchical task tree acquisition module is used to aggregate multiple original reconciliation tasks according to task dependency topology to obtain H hierarchical task trees; a priority setting module is used to reversely set multiple basic priorities of the multiple original reconciliation tasks from the H hierarchical task trees; a dynamic priority output module is used to evaluate task priorities based on the task attributes of the multiple original reconciliation tasks and output multiple dynamic priorities; a target correction task tree acquisition module is used to perform hierarchical correction and connection of the H hierarchical task trees according to the priority differences between the multiple basic priorities and the multiple dynamic priorities to obtain the target correction task tree. A positive task tree; a target correction task tree segmentation module, used to segment the target correction task tree into Q container-level task sets of Q task execution containers according to container performance; a scheduling chain output module, used to analyze the timing scheduling of the Q task execution containers according to the execution progress of the Q container-level task sets in the target correction task tree, and output an elastic rotation container scheduling chain; a dynamic scheduling reconciliation module, used to schedule the Q task execution containers along the target correction task tree in descending order of priority based on the elastic rotation container scheduling chain to perform dynamic scheduling reconciliation of the Q container-level task sets.

[0008] One or more technical solutions provided in this application have at least the following technical effects or advantages: According to the task dependency topology, multiple original reconciliation tasks are aggregated to obtain H hierarchical task trees; multiple basic priorities are set for the multiple original reconciliation tasks; task priorities are evaluated based on the task attributes of the multiple original reconciliation tasks, and multiple dynamic priorities are output; hierarchical correction and connection are performed on the H hierarchical task trees to obtain a target correction task tree; according to container efficiency, the target correction task tree is divided into Q container-level task sets of Q task execution containers; the timing scheduling of the Q task execution containers is analyzed to output an elastic rotation container scheduling chain; based on the elastic rotation container scheduling chain, the Q task execution containers are scheduled along the target correction task tree in descending order of priority to perform dynamic scheduling and reconciliation of the Q container-level task sets. This achieves the technical effect of realizing dynamic and efficient scheduling of reconciliation tasks based on priority, improving task execution efficiency, and optimizing resource allocation. BRIEF DESCRIPTION OF THE DRAWINGS

[0009] In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0010] Figure 1 A flowchart of a method for scheduling and managing reconciliation tasks based on dynamic priority provided in an embodiment of the present application; Figure 2 A schematic diagram of the structure of a reconciliation task scheduling and management system based on dynamic priority provided in an embodiment of the present application.

[0011] Explanation of the accompanying symbols: hierarchical task tree acquisition module 10, priority setting module 20, dynamic priority output module 30, target correction task tree acquisition module 40, target correction task tree segmentation module 50, scheduling chain output module 60, dynamic scheduling reconciliation module 70. DETAILED DESCRIPTION

[0012] This application provides a reconciliation task scheduling management method and system based on dynamic priority, which is used to solve the technical problems in the existing technology that reconciliation task scheduling lacks dynamic priority considerations, task execution efficiency is low, and resource allocation is unreasonable, resulting in time-consuming reconciliation work and serious waste of resources.

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

[0014] Example 1, as Figure 1 As shown, the present application provides a method for scheduling and managing reconciliation tasks based on dynamic priority, the method comprising: Step S100: Aggregate multiple original reconciliation tasks according to the task dependency topology to obtain H hierarchical task trees.

[0015] Specifically, a set of original reconciliation tasks is first obtained, each with a specific task identifier and content. The task dependency topology is modeled using a directed acyclic graph (DAG). Nodes in the graph represent the original reconciliation tasks, and directed edges indicate the dependencies between tasks. For example, if there is a directed edge from node A to node B, it means that task A is a predecessor of task B and that task B cannot start until task A completes. The task dependency topology is analyzed using the strongly connected component algorithm and topological sorting algorithm from graph theory. The strongly connected component algorithm identifies strongly connected components in the task dependency topology and groups interdependent tasks into the same set. These sets form the basis of a potential hierarchical task tree. Next, the topological sorting algorithm sorts the tasks within each strongly connected component to determine their execution order. During the aggregation process, related tasks are gradually combined into a hierarchical structure based on task dependencies and the topological sorting results. Each hierarchical task tree consists of multiple task nodes and directed edges connecting these nodes. The hierarchical relationship of the nodes reflects the execution order of tasks, with lower-level tasks being predecessors of higher-level tasks. In this way, H hierarchical task trees are finally obtained. These task trees provide a clear structural framework for subsequent task priority setting, task scheduling, and resource allocation, which helps to improve the efficiency and accuracy of reconciliation task scheduling.

[0016] Step S200: Reversely setting multiple basic priorities of the multiple original reconciliation tasks from the H hierarchical task trees.

[0017] Specifically, a task type weight set is first preset. This weight set is pre-configured based on factors such as the business importance and data sensitivity of different reconciliation tasks. For example, reconciliation tasks involving core financial data have a higher weight than ordinary flow verification tasks. For each original reconciliation task, the corresponding basic task weight is called from the task type weight set based on its task type. At the same time, the task hierarchical position of each original reconciliation task is extracted from the H hierarchical task trees. The hierarchical position reflects the order in which tasks are executed in the task tree. Bottom-level tasks are usually predecessor basic tasks with smaller hierarchical position values, while high-level tasks rely on bottom-level tasks for completion and have larger hierarchical position values. Afterwards, the basic task weight and task hierarchical position are calculated, and a weighted summation formula is used to assign different coefficients to the basic task weight and task hierarchical position. The basic priority of multiple original reconciliation tasks is set based on the calculation results. This basic priority provides an initial basis for subsequent priority adjustment and task scheduling based on the dynamic attributes of the task, ensuring that task scheduling has a reasonable execution sequence framework from the basic level.

[0018] Step S300: performing task priority evaluation based on the task attributes of the plurality of original reconciliation tasks, and outputting a plurality of dynamic priorities.

[0019] Specifically, after completing the basic priority setting, a more flexible and accurate dynamic evaluation of the priorities of the original reconciliation tasks is performed based on their task attributes, thereby outputting multiple dynamic priorities. Key task attributes are extracted for each original reconciliation task. First, a set of timeliness indicators is generated, including information such as the task's completion deadline and data update frequency. Based on these indicators, a first timeliness score is calculated using pre-set quantitative rules. For example, the tighter the task deadline and the more frequent the data update, the higher the timeliness score. Next, a monetary weighting is assigned based on the monetary value range involved in the task. Task amounts are categorized into different levels, such as small, medium, and large, with each level assigned a different monetary weight. Tasks with higher monetary values ​​are assigned a larger monetary weight, thereby highlighting the importance of high-value tasks. Then, based on the task type, historical data on the past execution success rate of tasks of that type is retrieved from locally stored historical data. This data reflects the reliability of tasks of that type in past executions. Finally, the obtained first timeliness score, first monetary weight, and first task execution success rate are input into the pre-built dynamic priority evaluation model. Based on a linear weighted algorithm, this model assigns specific weights to each input factor, determined by the importance of task attributes to their priority. Through this weighted calculation, the model ultimately outputs the first dynamic priority for each original reconciliation task. This dynamic priority evaluation mechanism fully considers the real-time nature of tasks, allowing task priorities to flexibly adjust based on actual conditions, providing a precise basis for more efficient subsequent task scheduling.

[0020] Step S400: performing hierarchical correction and connection of the H hierarchical task trees according to the priority differences between the multiple basic priorities and the multiple dynamic priorities to obtain a target corrected task tree.

[0021] Specifically, after obtaining the basic priority and dynamic priority of multiple original reconciliation tasks, the H hierarchical task trees are hierarchically corrected and connected according to the priority difference between the two to obtain the target corrected task tree. First, a priority difference scale is preset, which serves as a standard for judging whether the task priority difference is significant and is determined through empirical values ​​or simulation tests. For the P task nodes in the first hierarchical task tree, their basic priority and dynamic priority are obtained respectively, and the priority difference rate of each node is calculated to quantify the degree of priority difference. Based on the comparison results of the calculated P priority difference rates and the preset priority difference scale, T nodes to be corrected are located in the first hierarchical task tree. The priority difference of these nodes exceeds a reasonable range, and their hierarchical position in the task tree needs to be adjusted. These T nodes to be corrected are arranged in ascending order of priority to generate a sequence of nodes to be corrected. Subsequently, along the first hierarchical task tree, the T nodes to be corrected in the sequence are subjected to the same-level node priority balancing and parent node priority inheritance processing. During the peer priority balancing process, the order of peer nodes is adjusted based on their priorities, ensuring that higher-priority nodes are prioritized, thereby optimizing the order of task execution. During the parent node priority inheritance process, the priority of child nodes is adjusted to align with the priority logic of their parent nodes, maintaining the overall rationality of the task tree structure. This results in the first hierarchical correction tree. Following the same process, the hierarchical correction operation is performed on each of the H hierarchical task trees, ultimately outputting H hierarchical correction trees. To construct a complete target correction task tree, H root nodes and H groups of leaf nodes are selected from the H hierarchical correction trees. H virtual dependency features are constructed based on the dynamic priorities of these nodes. These virtual dependency features reflect the logical connections between different hierarchical correction trees. Based on these virtual dependency features, the H hierarchical correction trees are rationally connected to complete the construction of the target correction task tree. This target correction task tree comprehensively considers the fundamental and dynamic priorities of tasks, resulting in a more scientific and rational hierarchical structure, laying a solid foundation for the efficient scheduling of subsequent tasks.

[0022] Step S500: dividing the target modified task tree into Q container-level task sets of Q task execution containers according to container performance.

[0023] Specifically, after constructing the target revision task tree, the target revision task tree is rationally partitioned into Q container-level task sets for Q task execution containers. First, each of the Q task execution containers reports container performance data, including information such as a task type adaptation list, a task processing latency list, and the maximum number of parallel tasks. Based on this data, Q container performance matrices are initialized, providing a more intuitive matrix representation of each container's processing capabilities for different tasks. Next, the mean number of parallel tasks is extracted from the Q container performance data, and the subtree partitioning scale is calculated based on the task tree hierarchy depth. The task tree hierarchy depth reflects the complexity of the task tree, while the mean number of parallel tasks reflects the overall parallel processing capability of the container. These two factors are combined to determine the appropriate partitioning granularity, ensuring that the partitioned subtrees fully utilize container resources while being easy to manage and allocate. Then, using the calculated subtree partitioning scale, the target revision task tree is partitioned starting from its root node, resulting in multiple partitioned subtrees. To achieve rational task allocation, these partitioned subtrees are traversed using the Q container performance matrices. Taking the first container efficiency matrix as an example, traversing the first partition subtree matches the task type and task parallelism requirement. If the task type adaptation result is set to 1 (indicating that the container can handle the task type) and the task parallelism requirement adaptation result is set to 1 (indicating that the container can meet the parallel processing requirements of the task), the first container's fitness is output based on the task processing latency quantification. This fitness reflects the container's suitability for handling the task. Repeat this process for all containers and partition subtrees to obtain Q container fitnesses, which are then sorted in ascending order. Based on the sorted results, the top O task execution containers are extracted from the Q task execution containers to form the first set of candidate containers. This cycle repeats, performing cross-container allocation for multiple partition subtrees to obtain multiple sets of candidate containers. Finally, these multiple sets of candidate containers are screened for load balancing. Taking into account factors such as container load and task execution efficiency, multiple target task containers are determined. The partition subtrees corresponding to the target task containers are aggregated to ultimately obtain container-level task sets for each of the Q task execution containers. This ensures a reasonable distribution of tasks across containers and improves overall system processing efficiency.

[0024] Step S600: Analyze the timing scheduling of the Q task execution containers according to the execution progress of the Q container-level task sets in the target modified task tree, and output a flexible round-robin container scheduling chain.

[0025] Specifically, after partitioning the target revised task tree into Q container-level task sets for Q task execution containers, an efficient time-series scheduling analysis is performed on the Q task execution containers, resulting in an elastic round-robin container scheduling chain to optimize task execution efficiency. First, task processing latency lists are collected for each of the Q task execution containers. These lists record the average time required for each container to process different types of tasks. Based on these lists, the processing latency of each task in the Q container-level task sets is predicted. Taking into account factors such as task type, data volume, and the current container load, Q task processing latency sets are output, reflecting the expected processing time of each task on different containers. Simultaneously, the execution progress of the Q container-level task sets in the target revised task tree is monitored in real time to determine the current execution stage of each task. Combining the task processing latency sets and execution progress information, the time-series scheduling intervals for the Q task execution containers are calculated. For each container, the interval between the next task invocations is dynamically determined based on the completion status of its executed tasks, the expected processing time of its remaining tasks, and the execution status of other containers. During the computation process, high-priority tasks are prioritized. For containers involved in high-priority tasks, their scheduling intervals are appropriately shortened to allow them to process subsequent tasks more quickly. For containers handling lower-priority tasks and currently experiencing high loads, the scheduling intervals are appropriately extended to balance the allocation of system resources. This computational approach generates an elastic, rotating container scheduling chain. Within this scheduling chain, the same container is allowed to appear repeatedly. This is because different tasks have different suitability for containers. Some containers may be more adept at handling specific types of tasks and therefore be called multiple times to execute related tasks. Furthermore, the container call interval is not fixed but dynamically adjusted based on task processing latency and execution progress. This ensures that when tasks flow between containers, they fully utilize the container's processing power while flexibly adjusting the execution order and timing based on actual conditions. This improves the efficiency and flexibility of the entire reconciliation task scheduling system and ensures efficient and stable task execution.

[0026] Step S700: Based on the elastic round-robin container scheduling chain, the Q task execution containers are scheduled to perform dynamic scheduling reconciliation of the Q container-level task sets in descending order of priority along the target modified task tree.

[0027] Specifically, after obtaining an elastic round-robin container scheduling chain, Q task execution containers are finely scheduled according to this scheduling chain, achieving dynamic scheduling and reconciliation of Q container-level task sets in descending priority order along the target-corrected task tree. The Q task execution containers are invoked sequentially, strictly adhering to the order and time intervals determined by the elastic round-robin container scheduling chain. Each time a container is invoked, it prioritizes tasks from the container-level task sets corresponding to high-priority task nodes in the target-corrected task tree. Because the target-corrected task tree incorporates both base and dynamic priorities for hierarchical correction, its task priorities accurately reflect the urgency and importance of tasks. During the scheduling process, task execution status and container resource usage are continuously monitored. If a high-priority task encounters an exception or requires additional resources during execution, the scheduling policy is dynamically adjusted to prioritize the execution of that task. For example, if a container is found to be resource-constrained while processing a high-priority task, the execution of some lower-priority tasks is suspended, and idle resources from other containers are redeployed to support the processing of the high-priority task. Simultaneously, the elastic round-robin container scheduling chain is updated in real time based on task execution progress and container real-time performance. If a container completes its task ahead of schedule, the scheduling chain is adjusted promptly to schedule that container for the next task. If a container fails or experiences performance degradation, it is temporarily removed from the scheduling chain and its tasks are reassigned to other available containers to ensure that task scheduling is not affected. This dynamic scheduling approach continuously optimizes the task execution process, efficiently completing the reconciliation of Q container-level task sets, improving reconciliation accuracy and timeliness, and ensuring the stable and efficient operation of the entire reconciliation task scheduling and management system.

[0028] In one possible implementation, step S200 further includes: Step S210: Preset a task type weight set.

[0029] Step S220: calling a plurality of basic task weights of the plurality of original reconciliation tasks from the task type weight set based on the task type.

[0030] Step S230: extracting multiple task hierarchical positions of the multiple original reconciliation tasks from the H hierarchical task trees.

[0031] Step S240: setting the multiple basic priorities of the multiple original reconciliation tasks according to the multiple basic task weights and multiple task hierarchical positions.

[0032] Specifically, a set of task type weights is first preset. This set of weights serves as a key reference for setting the overall basic priority. It is constructed based on a comprehensive consideration of various factors, including the importance and complexity of different reconciliation tasks within the business process, as well as their impact on the overall reconciliation results. For example, for reconciliation tasks in the financial industry, reconciliation tasks involving core fund transactions are given a higher weight due to their direct impact on fund security and financial accuracy; while auxiliary data verification tasks are given a relatively lower weight.

[0033] Based on the task type of each original reconciliation task, the corresponding basic task weight is called from the pre-set task type weight set. In this way, each original reconciliation task is assigned a basic weight value that represents the importance of its task type.

[0034] Extract the hierarchical positions of the original reconciliation tasks from the H constructed hierarchical task trees. This hierarchical position information intuitively reflects the order in which tasks are executed within the task tree. Lower-level tasks are often prerequisites for completing higher-level tasks, and their hierarchical position is closely related to the order in which tasks are executed.

[0035] When setting the base priority of original reconciliation tasks, two key factors are considered: the weights of multiple base tasks and the hierarchical position of multiple tasks. Assume there are three original reconciliation tasks, A, B, and C. Within the preset task type weights, Task A has a base weight of 0.8 (because it involves reconciling core business data and is therefore of higher importance), Task B has a base weight of 0.5 (as part of general business data verification), and Task C has a base weight of 0.3 (as an auxiliary data comparison task). From the H hierarchical task trees, we can see that Task A is at level 2, Task B at level 3, and Task C at level 4. The base priority is set using a weighted calculation, assuming a coefficient of 0.8 for the base weight and a coefficient of 0.2 for the hierarchical position of the task (these coefficients are set based on the proportion of task scheduling importance). To calculate Task A's base priority: multiply the base task weight of 0.8 by the coefficient of 0.8 to get 0.64; multiply the task's hierarchical position of 2 by the coefficient of 0.2 to get 0.4. Adding these two together, Task A's base priority is 1.04. Similarly, Task B's base priority is 0.5 × 0.8 + 3 × 0.2 = 1, and Task C's base priority is 0.3 × 0.8 + 4 × 0.2 = 1.04. This calculation method, combining base task weight and hierarchical position, sets a reasonable base priority for each original reconciliation task. This ensures that subsequent tasks, such as Task C, which has a lower task type weight but a lower hierarchical position and is considered preemptive, can be appropriately scheduled. Important tasks, such as Task A, which is higher in the hierarchical position, will be prioritized, ensuring the orderliness and efficiency of the entire reconciliation task scheduling process.

[0036] In one possible implementation, step S300 further includes: Step S310: extracting a first timeliness indicator set of the first original reconciliation task, and quantifying and outputting a first timeliness score based on the first timeliness indicator set.

[0037] Step S320: performing amount weight classification according to the task amount range in which the first original reconciliation task is located, and setting a first amount weight.

[0038] Step S330: Locally call the first task execution success rate according to the task type of the first original reconciliation task.

[0039] Step S340: Inputting the first timeliness score, the first amount weight, and the first task execution success rate into a dynamic priority evaluation model for linear weighting to output a first dynamic priority.

[0040] Specifically, for the first original reconciliation task, its first timeliness indicator set is extracted. This indicator set mainly includes the task creation time, deadline time, and current time. By obtaining this time information, the remaining processing time of the task is calculated, that is, the difference between the deadline time and the current time. Then, the remaining processing time is divided by the total time limit (the difference between the deadline time and the creation time) to obtain the ratio of the remaining processing time to the total time limit. In order to convert this ratio into a score that better reflects the timeliness of the task, an exponential decay function is applied. The exponential decay function S= , where S is the dependent variable of the function, that is, the output value, which in this case represents the timeliness score calculated based on the remaining time ratio. is a natural constant, Is the decay coefficient, which is an adjustable parameter. It determines the decay rate of the timeliness score as the remaining time changes. The larger it is, the smaller the remaining time ratio is, and the faster the timeliness score S decreases, that is, the more obvious the urgency of the task is. is an independent variable representing the ratio of the remaining processing time to the total time limit, with a value range of [0, 1]. The closer R is to 1, the more sufficient the remaining time is; the closer R is to 0, the less time is left. Under the action of the exponential decay function, the remaining time ratio is associated with the timeliness score. When the remaining time ratio is large, it means that there is still more time to process the task, and the timeliness score calculated by the function will be low, indicating that its urgency is relatively low; and when the remaining time ratio is small, that is, the less time is left, the higher the timeliness score calculated by the function, indicating that the priority urgency of the task is higher. In this way, the first timeliness score is quantitatively output based on the first timeliness indicator set, providing an important time dimension consideration for the subsequent dynamic priority evaluation.

[0041] Based on the amount involved in the first original reconciliation task, the task amount range is determined. These amount ranges are pre-set, for example, categorizing reconciliation amounts into small amounts (e.g., less than 10,000 yuan), medium amounts (10,000-100,000 yuan), and large amounts (greater than 100,000 yuan). Different ranges correspond to different weight levels, and amount weighting is graded according to pre-set rules. If the task amount falls within the large amount range, a higher weight is assigned; if it falls within the small amount range, a relatively lower weight is assigned. This creates a first amount weight, which reflects the impact of the task amount on task priority.

[0042] Based on the task type of the first original reconciliation task, a search is performed in the locally stored data. The local database stores past execution success rate data for different task types, and the execution success rate of the corresponding first task is precisely retrieved based on the task type. For example, if the task type is a regular account reconciliation, its execution success rate is retrieved from the stored regular account reconciliation task data; if it is a special account reconciliation task, the execution success rate data for the special account reconciliation task is retrieved. This execution success rate reflects the success rate of this type of task in previous executions, providing a reference for historical execution status to assess the priority of the current task.

[0043] The first timeliness score, first monetary weight, and first task execution success rate obtained previously are input into the dynamic priority evaluation model. This model uses a linear weighted approach for calculations, assigning a corresponding weight coefficient to each input value. Assume that the weight coefficient for the first timeliness score is w1, the weight coefficient for the first monetary weight is w2, and the weight coefficient for the first task execution success rate is w3, and that w1 + w2 + w3 = 1. The first dynamic priority is calculated using the formula: First Dynamic Priority = w1 × First Timeliness Score + w2 × First Monetary Weight + w3 × First Task Execution Success Rate, ultimately outputting the first dynamic priority. This priority takes into account multiple factors, including the time urgency of the task, the amount involved, and the historical execution success rate. It provides a more scientific and reasonable priority basis for subsequent reconciliation task scheduling, ensuring that important and urgent tasks are prioritized.

[0044] In one possible implementation, step S400 further includes: Step S410: Preset a priority difference scale.

[0045] Step S420 : Calculate and output P priority difference rates based on the P basic priorities and P dynamic priorities of the P task nodes in the first hierarchical task tree.

[0046] Step S430: Locate T nodes to be corrected in the first hierarchical task tree according to whether the P priority difference rates meet the priority difference standard.

[0047] Step S440: Arrange the T nodes to be corrected in ascending order based on priority to obtain a sequence of nodes to be corrected.

[0048] Step S450: According to the sequence of nodes to be corrected, along the first hierarchical task tree, the T nodes to be corrected are subjected to peer node priority balancing and parent node priority inheritance processing one by one to obtain a first hierarchical correction tree.

[0049] Step S460: Similarly, the levels of the H hierarchical task trees are corrected according to the priority differences between the multiple basic priorities and the multiple dynamic priorities, and H hierarchical corrected trees are output.

[0050] Step S470: Connecting the H-level correction trees by constructing virtual dependencies to complete the construction of the target correction task tree.

[0051] Specifically, a preset priority difference scale is required. This scale serves as the core basis for determining whether task node priorities require adjustment. This scale includes two key thresholds: the absolute difference threshold ΔP between the dynamic priority and the base priority, and the relative difference rate threshold δ%. System administrators determine these thresholds based on business needs, task characteristics, and past task scheduling experience. The absolute difference threshold ΔP directly measures the numerical difference between the dynamic priority and the base priority. For example, if ΔP is set to 3, a task node's priority experiencing a significant change when its dynamic priority differs from its base priority by more than 3 indicates a significant change in priority. This helps quickly identify task nodes with significant priority changes, providing clear targets for subsequent adjustments. The relative difference rate threshold δ% more accurately reflects the extent of the change in priority from a proportional perspective. For example, if δ% is set to 15%, a task node will be included in subsequent evaluations if its dynamic priority exceeds 15% compared to its base priority. The relative difference rate threshold accounts for differences in base priorities among different task nodes, avoiding potential omissions that might be overlooked when judging solely based on absolute differences. For example, if one task node has a lower base priority, its absolute difference may change slightly, but the relative change may be larger. Meanwhile, if the other task node has a higher base priority, its absolute difference may change significantly, but the relative change may not be significant. By combining these two thresholds, we can comprehensively and meticulously select task nodes requiring priority adjustment, laying a solid foundation for subsequent optimization of the task tree's hierarchical structure.

[0052] For each of the P task nodes in the first hierarchical task tree, the system obtains the base priority and dynamic priority of each node and calculates the difference between them. Using the formula (dynamic priority - base priority) ÷ base priority × 100% (when the base priority is not 0), the system obtains the P priority difference rates. These difference rates reflect the degree of deviation between the dynamic priority and the base priority of each task node.

[0053] Compare P priority difference rates against a preset priority difference scale. If a task node's priority difference rate exceeds ΔP in absolute value, or exceeds δ% in relative value, the node is identified as requiring correction. After screening, T such nodes for correction are identified in the first hierarchical task tree. These nodes become the focus of subsequent adjustments.

[0054] Arrange the T nodes to be corrected in ascending order of priority to generate a sequence of nodes to be corrected. This ordering helps to adjust the node priorities in an orderly manner, starting with the nodes with lower priorities, to avoid confusion and errors.

[0055] Based on the sorted sequence of nodes to be corrected, operations are performed on these T nodes in order. For each node to be corrected, priority balancing is first performed with its peers. This process comprehensively considers the various task characteristics of the node and its peers, such as task urgency, importance, and resource requirements. Priority values ​​are adjusted to ensure a more balanced distribution of priorities among nodes at the same level, preventing a node from having too high or too low a priority, which could affect overall task scheduling efficiency. Subsequently, priority inheritance is performed on the parent node. The priority characteristics of the parent node to be corrected are analyzed, and according to specific rules, the parent node's priority attributes are transferred to the node to be corrected. For example, if the parent node has a higher priority, indicating that its child tasks are also of high importance, the node to be corrected will inherit the corresponding priority increase. Conversely, if the parent node has a lower priority, the node to be corrected may also have its priority reduced appropriately. This peer-to-peer priority balancing and parent-to-peer priority inheritance process is repeated for each node to be corrected until all T nodes to be corrected have been processed. After this series of processing, the structure and node priority of the first-level task tree were optimized and adjusted, and finally the first-level correction tree was obtained, which provided strong support for subsequent more efficient task scheduling and execution.

[0056] The H hierarchical task trees are processed one by one. By repeatedly calculating the priority difference rate, locating the nodes to be corrected, sorting, and correcting them, H hierarchical correction trees are output, so that each hierarchical task tree can be optimized based on the difference between the dynamic priority and the basic priority.

[0057] After obtaining H hierarchical correction trees, they are integrated into a complete target correction task tree. The characteristics of each task node in the H hierarchical correction trees, the logical relationships between tasks, and the overall business process requirements are analyzed to construct virtual dependencies. Virtual dependencies are not actual task execution dependencies, but rather artificially created relationships to rationally connect different hierarchical correction trees. Key nodes within the hierarchical correction trees that can be interconnected are identified, and virtual dependencies are created for these key nodes based on factors such as task sequence, data flow, and resource sharing. For example, if the output of a task node in one hierarchical correction tree is the input of a task node in another hierarchical correction tree, a virtual dependency is established between the two nodes. By constructing a series of these virtual dependencies, the H separate hierarchical correction trees are gradually connected to form an organic whole. Once all necessary virtual dependencies are constructed, the H previously independent hierarchical correction trees are seamlessly connected, ultimately completing the construction of the target correction task tree.

[0058] In one possible implementation, step S470 further includes: Step S471: Filter out H root nodes and H groups of leaf nodes from the H hierarchical revised trees.

[0059] Step S472: Constructing H virtual dependency features of the H hierarchical correction trees according to the dynamic priorities of the H root nodes and the H groups of leaf nodes.

[0060] Step S473: Based on the H virtual dependency features, the H hierarchical correction trees are connected to complete the construction of the target correction task tree.

[0061] Specifically, a comprehensive review of H hierarchical revision trees is performed. For each hierarchical revision tree, its root node (i.e., the starting node without a parent node) and leaf nodes (i.e., the ending node without child nodes) are accurately identified and filtered. This step forms the foundation for the subsequent construction of virtual dependencies. By extracting these key nodes, we prepare the way for establishing connections between hierarchical revision trees. For example, the root node of hierarchical revision tree A is task A1, and its leaf nodes include tasks A5, A8, and so on. This information is recorded and the same process is performed on all H hierarchical revision trees, resulting in H root nodes and H groups of leaf nodes.

[0062] A virtual dependency feature is constructed based on the dynamic priorities of these screened H root nodes and H groups of leaf nodes. The dynamic priority reflects the importance and execution urgency of the task, and the dynamic priority differences of the root nodes and leaf nodes of different hierarchical correction trees are analyzed. If the root node of a hierarchical correction tree has a higher dynamic priority, while the leaf nodes of another hierarchical correction tree have a lower dynamic priority, and they have a potential connection in business logic, a virtual dependency feature is constructed based on this priority relationship and business logic. For example, a connection rule is set so that the hierarchical correction tree where the high-priority root node is located takes precedence over the hierarchical correction tree where the low-priority leaf node is located in the task execution order, or a virtual path for data transmission is established. By performing such analysis and rule setting on each group of root nodes and leaf nodes, H virtual dependency features are constructed for each of the H hierarchical correction trees.

[0063] Based on the H constructed virtual dependency features, H hierarchical correction trees are connected. Each hierarchical correction tree is connected together according to the rules and connections set by the virtual dependency features. For example, according to the execution order and data transfer path determined by the virtual dependency features, the nodes of the different hierarchical correction trees are connected in an orderly manner, allowing tasks to be executed in a reasonable order and data to be smoothly transferred between the different hierarchical correction trees. When all the hierarchical correction trees are connected according to the virtual dependency features, the target correction task tree is successfully constructed. This target correction task tree integrates the advantages of each hierarchical correction tree while taking into account the priority and logical relationships of tasks, providing an efficient and reasonable overall framework for subsequent task scheduling and execution.

[0064] In one possible implementation, step S500 further includes: Step S510: Initialize Q container performance matrices according to the Q container performance data reported by the Q task execution containers.

[0065] Step S520 : extracting the average number of parallel tasks from the Q container performance data, and calculating the subtree partitioning scale according to the task tree level depth and the average number of parallel tasks.

[0066] Step S530: using the subtree segmentation scale to segment the target correction task tree from the root node to obtain a plurality of segmented subtrees.

[0067] Step S540: traverse the multiple partition subtrees using the Q container efficiency matrices to perform cross-container load balancing distribution of tasks to obtain the Q container-level task sets.

[0068] Specifically, during the process of rationally allocating the target corrected task tree to Q task execution containers, each of the Q task execution containers reports its container performance data in real time. This data includes a task type adaptation list, a task processing latency list, and the maximum number of concurrent tasks. Upon receiving this data, each task execution container is processed separately. For one container, the reported task type adaptation list is used to determine the various reconciliation task types that the container can handle, and these are used as row or column identifiers in a matrix. For the task processing latency list, the processing times corresponding to different task types are filled in the corresponding positions in the matrix, reflecting the time required for the container to process each task. The maximum number of concurrent tasks may be represented as a specific identifier or numerical value in a specific area of ​​the matrix, representing the container's parallel processing capability. Similarly, matrices are constructed for each of the Q task execution containers, ultimately initializing the Q container performance matrices. These matrices provide an intuitive and systematic data foundation for subsequent analysis of the container's processing capabilities for different tasks, calculation of subtree partitioning scales, and cross-container load balancing of tasks, and are a crucial prerequisite for efficient task allocation and scheduling.

[0069] First, traverse the Q container performance data, extract the maximum task parallelism of each task execution container, obtain the Q maximum task parallelism, add these Q maximum task parallelisms, and divide them by the number of containers Q, that is, to obtain the mean number of tasks, which is recorded as In this way, we can get the average number of parallel tasks of Q containers , which represents the average level of the overall parallel processing capabilities of these containers. At the same time, the hierarchical depth D of the target modified task tree is obtained. This depth reflects the complexity of the task tree. The deeper the hierarchy, the more complex the dependencies and execution logic between tasks. Then, a weighted algorithm is used to calculate the subtree partitioning scale S. The mean number of parallel tasks and the depth of the task tree are assigned weights respectively. and , and satisfies + =1. The distribution of these two weights depends on the emphasis on the container's parallel processing capability and the complexity of the task tree in the actual business scenario. If the container's parallel processing capability is more emphasized, the ; If you pay more attention to the complexity of the task tree, increase Finally, the calculation formula of subtree split scale S is S= × + ×D. When splitting the target to modify the task tree, the splitting scale standard must meet the following requirements: the number of subtree tasks after splitting must be between 0.5 and 1.5 times the average number of parallel tasks to avoid waste of container resources or task blocking; the hierarchical depth of the subtree must not exceed the splitting scale calculated by the weighted algorithm (S= × + ×D), ensuring that the complexity of task dependencies is within a reasonable range; all pre-dependent tasks within a subtree must be fully contained within the subtree to prevent task chain breaks; the standard deviation of the number of tasks in all split subtrees must be controlled within 0.3 times the mean number of parallel tasks to ensure load balancing between containers; when the subtree task density (the ratio of the number of tasks to the hierarchical depth) exceeds 2, the weight of the mean number of parallel tasks is automatically increased and the split scale is recalculated to accommodate the processing needs of task-intensive branches. These multi-dimensional standards ensure that the split operation is scientific, reasonable, and executable. The subtree split scale derived through this weighted algorithm fully combines the parallel processing capabilities of the container and the structural characteristics of the task tree, providing a scientific basis for subsequent reasonable split target modification of the task tree, thereby achieving efficient distribution of tasks among Q task execution containers.

[0070] After determining the subtree splitting scale, the splitting process begins at the root node of the target correction task tree. The subtree splitting scale defines the criteria for splitting subtrees, such as the number of tasks and the span of task hierarchies. Starting with the root node, the subtree splitting scale is used to determine whether the set of tasks consisting of the root node and its child nodes meets the splitting scale requirements. If so, this set of tasks is divided into a split subtree. If not, the splitting scale is further expanded downward to include child nodes at the next level until the criteria specified by the splitting scale are met. During this process, inter-task dependencies are carefully considered to ensure that the tasks within each split subtree are coherent and logically complete, avoiding situations where a task cannot be executed independently due to being split. As the splitting operation continues, the entire target correction task tree is split layer by layer from the root node downward until the entire task tree is fully split, ultimately resulting in multiple split subtrees. In subsequent task scheduling, these split subtrees are treated as independent task units and assigned to Q task execution containers, enabling parallel processing and optimal distribution of tasks, thereby improving overall task processing efficiency.

[0071] The first container efficiency matrix is ​​used to traverse the first partition subtree. Task types and task parallelism requirements are matched against the tasks in the subtree and the container. If the task type is successfully matched, the matching result is set to 1. Simultaneously, the task parallelism requirement is also successfully matched and set to 1. A quantitative calculation is then performed based on the task processing latency of the container, outputting the first container fitness. Following the same method, the Q container efficiency matrices are traversed through the first partition subtree to obtain Q container fitnesses. These Q container fitnesses are then sorted in ascending order. Based on the sorted results, the top 0 task execution containers are extracted from the Q task execution containers to form the first set of candidate containers. The above process is then repeated for the remaining partition subtrees, using the Q container efficiency matrices to traverse each partition subtree in turn. After matching task types and parallelism requirements, calculating fitnesses, and sorting, multiple sets of candidate containers are obtained. These multiple sets of candidate containers are then screened for load balancing, taking into account factors such as the current load and processing capacity of each container to avoid overloading or underloading any given container. This results in multiple target task containers being selected. Finally, based on the multiple target task containers identified, the corresponding split subtrees are aggregated. The split subtrees corresponding to each target task container are aggregated together to form Q container-level task sets, achieving a reasonable distribution of tasks across the Q task execution containers and load balancing across containers.

[0072] In one possible implementation, step S510 further includes: Step S511: The container performance data includes a task type adaptation list, a task processing delay list, and a maximum number of parallel tasks.

[0073] Specifically, container performance data consists of three core parts. The task type adaptation list details the various types of tasks that a container can handle, and clearly indicates the container's support for different business-type tasks (such as data calculation, file transfer, logical judgment, etc.). This list allows you to intuitively determine whether a container is suitable for a specific task type. The task processing latency list records the average time required for the container to process different types of tasks, reflecting the efficiency of the container in processing tasks. The shorter the latency, the faster the container processes the corresponding tasks. The maximum number of parallel tasks indicates the maximum number of tasks that a container can process in parallel at the same time, reflecting the container's parallel processing capabilities. The larger the value, the stronger the container's performance in concurrent multi-task processing. These three parts of data together constitute the container performance data, providing an important reference for subsequent tasks allocation, subtree splitting scale calculation, and other operations, helping to comprehensively evaluate the container's ability to process tasks and its adaptability.

[0074] In one possible implementation, step S540 further includes: Step S541: traverse the first partition subtree using the first container efficiency matrix to match task types with task parallelism requirements.

[0075] Step S542: If the task type adaptation result is set to 1 and the task parallel requirement adaptation result is set to 1, the first container adaptation degree is output based on the task processing delay quantification.

[0076] Step S543: Similarly, after obtaining the Q container fitnesses, the Q container fitnesses are sorted in ascending order, so as to extract the first O task execution containers from the Q task execution containers according to the sorting result to form a first group of candidate containers.

[0077] Step S544: Similarly, the Q container efficiency matrices are used to traverse the multiple partition subtrees, and tasks are allocated across containers to obtain multiple groups of candidate containers.

[0078] Step S545: load balancing and screening are performed on the multiple groups of candidate containers to obtain multiple target task containers.

[0079] Step S546: Aggregate the multiple split subtrees according to the multiple target task containers to obtain the Q container-level task sets.

[0080] Specifically, the task allocation and matching work is carried out, and the first container efficiency matrix is ​​extracted. The matrix contains data such as the adaptation information of the first task execution container for different task types, task processing delay, and maximum task parallelism. Subsequently, this matrix is ​​applied to the first split subtree, and each task in the subtree is analyzed in detail. For each task, its task type is checked and compared with the task type that can be processed by the first container recorded in the matrix to determine whether the container has the ability to process this task type. At the same time, the parallel requirements of the task are considered, that is, whether the task needs to be carried out simultaneously with other tasks during execution, and the number of parallel resources required, and these requirements are matched with the maximum task parallelism of the first container in the matrix. In this way, it is possible to clarify the adaptation of the first container to each task in the first split subtree in terms of task type and task parallelism requirements.

[0081] If the task type adaptation result is 1 and the task parallel requirement adaptation result is also 1, the following algorithm will be used to quantify the output of the first container's adaptation degree. First, suppose there are n tasks in the first partition subtree. For the i-th task, its processing delay is obtained from the first container's efficiency matrix as t i , and pre-set the weight of each task as w according to the importance of the task i , and satisfies = 1. Calculate the weighted sum of task processing delays T = ×t iThis step comprehensively considers the importance of different tasks and their processing delays. Then, a benchmark delay value T0 is introduced, which is the ideal processing delay value determined based on historical experience, system performance standards, etc. Calculate the first container's fitness, A. A larger value indicates that the actual latency of the first container processing the split subtree task is longer than the baseline latency, and the fitness is lower. Conversely, a value closer to 1 or even less than 1 indicates that the first container is more efficient in processing these tasks, and the fitness is higher. This algorithm calculates the fitness of the first container, providing a quantified indicator for subsequent task allocation.

[0082] Following the same process, the Q container efficiency matrices are sequentially traversed through the first partition subtree to obtain the Q container fitness scores. These fitness scores are then sorted in ascending order, and the top O task execution containers are extracted from the Q task execution containers based on the sorting results to form the first set of candidate containers. This sorting and screening method prioritizes containers with high fitness scores, providing better choices for task allocation.

[0083] In the same way as processing the first split subtree, each of the remaining split subtrees is traversed in turn using the Q container efficiency matrices. For each new split subtree, the task type and task parallel requirement are matched. If the match is successful (i.e., the task type adaptation result is set to 1 and the task parallel requirement adaptation result is set to 1), then the adaptability of each container to the split subtree is quantified and output based on the task processing delay, and Q container adaptabilities are obtained. Then, these Q container adaptabilities are sorted in ascending order, and the top O task execution containers are extracted from the Q task execution containers based on the sorting result to form a set of candidate containers for the split subtree. By repeating this process continuously, the above operations are completed one by one for multiple split subtrees, and finally multiple groups of candidate containers are obtained. These multiple groups of candidate containers cover the container combinations with higher adaptability for each split subtree, providing a rich selection basis for achieving cross-container load balancing distribution of tasks.

[0084] After obtaining multiple candidate containers, a detailed evaluation system was constructed to collect key information about each candidate container, such as current CPU usage, memory usage, number of assigned tasks, average processing latency, historical throughput, and maximum number of parallel processing tasks. These indicators were then quantified and normalized to eliminate dimensional differences. The indicators of candidate containers were divided into two categories: For indicators such as CPU usage and memory usage, lower values ​​are preferred, with a value of 1- Convert to score, the larger the value of historical throughput, the better the indicator, directly use After the transformation, each metric is assigned appropriate weights based on business needs and system characteristics. A weighted average algorithm is used to calculate the overall score of each candidate container. When allocating tasks, candidate containers with the highest overall scores are selected based on the task characteristics of the split subtree, such as task type, expected execution time, and parallelism requirements. Each selection is checked to see if the container's remaining processing capacity can meet the split subtree's task requirements. If not, the container is skipped and the next one is selected. Furthermore, a dynamic monitoring and adjustment mechanism is implemented to update the load information of each container in real time during the allocation process. After a certain number of split subtrees are allocated, the overall score of each container is recalculated, and subsequent allocations are dynamically optimized. Furthermore, to avoid single points of failure and excessive resource concentration, restriction rules are implemented. For example, critical tasks of the same type are distributed across different containers, and the maximum number of tasks a single container can handle is controlled. Through this comprehensive, dynamic, and rational screening and allocation process, multiple target task containers are identified from multiple groups of candidate containers, achieving load balancing of tasks and improving overall operational efficiency and stability.

[0085] Multiple split subtrees are aggregated around these containers to form Q container-level task sets. A mapping relationship is established to associate each split subtree with its corresponding target task container. Split subtrees that have been determined to be assigned to the same target task container are merged according to certain rules. For example, logically coherent split subtrees are integrated based on the execution order and dependencies of the tasks to ensure that tasks within the same container can be executed efficiently and orderly. During the aggregation process, the task set is optimized and adjusted to remove duplicate or redundant tasks, and the dependencies between tasks are further sorted out, so that each container-level task set becomes a complete and independent task set. With the completion of the aggregation operation, the previously dispersed multiple split subtrees are integrated into the Q target task containers, forming Q container-level task sets. These task sets will serve as the basic units for subsequent task execution, providing each task execution container with a clear task execution plan, achieving a reasonable division of labor between tasks in different containers, and ensuring the efficient and stable operation of the entire task scheduling.

[0086] In one possible implementation, step S600 further includes: Step S610: performing task processing delay prediction on the Q container-level task sets according to the Q task processing delay lists of the Q task execution containers, and outputting Q task processing delay sets.

[0087] Step S620: Calculate the timing scheduling intervals of the Q task execution containers based on the Q task processing latency sets and the execution progress of the Q container-level task sets in the target modified task tree, and output the elastic round-robin container scheduling chain.

[0088] Specifically, a long short-term memory (LSTM) network is used to predict task processing latency for Q container-level task sets, outputting Q sets of task processing latency. LSTM is a special type of recurrent neural network that excels at processing time series data and effectively captures long-term dependencies in the data, which is crucial for prediction based on historical task processing latency data. The Q task processing latency lists of the Q task execution containers are organized into a time series format as training data. Each container's task processing latency list contains historical latency data for multiple time steps, along with corresponding feature information such as task type and number. This data is normalized to map values ​​in different ranges to the same interval, improving model training performance. An LSTM model is then constructed. The model consists of an input layer, multiple LSTM layers, and an output layer. The input layer receives preprocessed data, while the LSTM layer learns the time series features and long-term dependencies in the data. Memory cells update their own state based on the input information and previous states, selectively forgetting and retaining information. Stacking multiple LSTM layers enables deeper extraction of complex features. The model is then trained using the organized training data. During training, the backpropagation algorithm continuously adjusts model parameters, such as weights and biases, to minimize the error between the predicted results and the actual latency. A common loss function is the mean squared error (MSE) loss function. Training continues for multiple rounds until the model's loss converges to a smaller range, indicating good training results. After training is complete, the relevant data (task type, number, etc.) for the Q container-level task sets is input into the trained LSTM model. Based on the learned patterns and features, the model predicts the time required for each container to process its corresponding task set, ultimately outputting a set of Q task processing latencies.

[0089] Based on the resulting Q task processing latency sets and the execution progress of the Q container-level task sets in the target revised task tree, the work rhythm of the task execution containers is carefully planned to generate a flexible round-robin container scheduling chain. First, the execution progress of each container-level task set in the target revised task tree is carefully analyzed, such as determining which task nodes have been completed and the completion percentage. Combined with the corresponding task processing latency sets, the estimated time required for each task execution container to complete the remaining tasks is determined. For example, if container A and container B have an estimated processing time of Ta for the current task set and 30% of the tasks have been completed in the target revised task tree, the estimated processing time for the remaining tasks is 0.7Ta. If container B's task processing latency set indicates an estimated processing time of Tb for its task set and 20% of the tasks have been completed, the estimated remaining processing time is 0.8Tb. This information, along with factors such as inter-task dependencies, is used to calculate the inter-container scheduling interval. If some tasks in container B depend on the output of container A before they can be executed, container B must start after container A completes the output of the relevant tasks. The scheduling interval between them is the remaining time for container A to complete the relevant tasks. During the calculation process, the system fully considers the possible changes in task processing latency in real situations. For example, unexpected situations may cause a container to process tasks more slowly, or the impact of new tasks on overall scheduling. The scheduling interval is then dynamically adjusted. Finally, based on these calculation results, an elastic round-robin container scheduling chain is generated. In this scheduling chain, the same container is allowed to appear repeatedly. This is because in a complex task system, a container may need to participate in the processing of tasks at different stages multiple times. The interval between each call to the container is dynamically adjusted based on the actual task execution progress and processing latency to ensure that tasks can flow efficiently and orderly between containers, maximizing task execution efficiency and optimizing system resource allocation.

[0090] Example 2 is based on the same inventive concept as the method for scheduling and managing reconciliation tasks based on dynamic priority in the previous embodiment. Figure 2 As shown, the present application provides a reconciliation task scheduling and management system based on dynamic priority. The system and method embodiments in the present application are based on the same inventive concept. The system includes: The hierarchical task tree acquisition module 10 is used to aggregate multiple original reconciliation tasks according to the task dependency topology to obtain H hierarchical task trees.

[0091] The priority setting module 20 is configured to reversely set a plurality of basic priorities of the plurality of original reconciliation tasks from the H hierarchical task trees.

[0092] The dynamic priority output module 30 is configured to evaluate the task priorities based on the task attributes of the plurality of original reconciliation tasks and output a plurality of dynamic priorities.

[0093] The target revised task tree acquisition module 40 is used to perform hierarchical revision connection of the H hierarchical task trees according to the priority differences between the multiple basic priorities and the multiple dynamic priorities to obtain a target revised task tree.

[0094] The target correction task tree segmentation module 50 is configured to segment the target correction task tree into Q container-level task sets of Q task execution containers according to container performance.

[0095] The scheduling chain output module 60 is configured to perform a timing scheduling analysis on the Q task execution containers according to the execution progress of the Q container-level task sets in the target modified task tree, and output a flexible round-robin container scheduling chain.

[0096] The dynamic scheduling reconciliation module 70 is configured to schedule the Q task execution containers to perform dynamic scheduling reconciliation of the Q container-level task sets in descending order of priority along the target modified task tree based on the elastic round-robin container scheduling chain.

[0097] Furthermore, the system is also used to implement the following functions: Preset a task type weight set; call multiple basic task weights of the multiple original reconciliation tasks from the task type weight set based on the task type; extract multiple task hierarchy positions of the multiple original reconciliation tasks from the H hierarchical task trees; set the multiple basic priorities of the multiple original reconciliation tasks based on the multiple basic task weights and the multiple task hierarchy positions.

[0098] Furthermore, the system is also used to implement the following functions: Initialize Q container efficiency matrices based on the Q container efficiency data reported by the Q task execution containers; extract the mean number of parallel tasks from the Q container efficiency data, and calculate the subtree splitting scale based on the task tree hierarchy depth and the mean number of parallel tasks; use the subtree splitting scale to split the target modified task tree from the root node to obtain multiple split subtrees; use the Q container efficiency matrices to traverse the multiple split subtrees, perform cross-container load balancing distribution of tasks, and obtain the Q container-level task sets.

[0099] Furthermore, the system is also used to implement the following functions: The first container efficiency matrix is ​​used to traverse the first partition subtree to match the task type and the task parallel requirement. If the task type adaptation result is set to 1 and the task parallel requirement adaptation result is set to 1, the first container fitness is output based on the task processing delay quantification. Similarly, after obtaining Q container fitnesses, the Q container fitnesses are arranged in ascending order to extract the first O task execution containers from the Q task execution containers according to the sorting result to form a first group of candidate containers. Similarly, the Q container efficiency matrices are used to traverse the multiple partition subtrees to perform cross-container distribution of tasks to obtain multiple groups of candidate containers. The multiple groups of candidate containers are load balanced and screened to obtain multiple target task containers. Based on the multiple target task containers, the multiple partition subtrees are aggregated to obtain the Q container-level task sets.

[0100] Furthermore, the system is also used to implement the following functions: The container performance data includes a task type adaptation list, a task processing delay list, and a maximum number of parallel tasks.

[0101] Furthermore, the system is also used to implement the following functions: Extract the first timeliness indicator set of the first original reconciliation task, and quantitatively output a first timeliness score based on the first timeliness indicator set; perform amount weight grading according to the task amount range in which the first original reconciliation task is located, and set a first amount weight; locally call the first task execution success rate according to the task type of the first original reconciliation task; input the first timeliness score, the first amount weight, and the first task execution success rate into the dynamic priority evaluation model for linear weighting, and output the first dynamic priority.

[0102] Furthermore, the system is also used to implement the following functions: A priority difference scale is preset; based on the P basic priorities and P dynamic priorities of the P task nodes in the first hierarchical task tree, P priority difference rates are calculated and output; based on whether the P priority difference rates meet the priority difference scale, T nodes to be corrected are located in the first hierarchical task tree; the T nodes to be corrected are arranged in ascending order based on priority to obtain a sequence of nodes to be corrected; based on the sequence of nodes to be corrected, the T nodes to be corrected are performed one by one along the first hierarchical task tree on priority balancing of the same level nodes and inheritance of priority of the parent node to obtain a first hierarchical correction tree; and so on, the hierarchical correction of the H hierarchical task trees is performed based on the priority differences of the multiple basic priorities and the multiple dynamic priorities, and H hierarchical correction trees are output; the construction of the target correction task tree is completed by constructing virtual dependencies to connect the H hierarchical correction trees.

[0103] Furthermore, the system is also used to implement the following functions: Filter out H root nodes and H groups of leaf nodes from the H hierarchical correction trees; construct H virtual dependency features of the H hierarchical correction trees based on the dynamic priorities of the H root nodes and H groups of leaf nodes; connect the H hierarchical correction trees based on the H virtual dependency features to complete the construction of the target correction task tree.

[0104] Furthermore, the system is also used to implement the following functions: According to the Q task processing delay lists of the Q task execution containers, task processing delay prediction is performed on the Q container-level task sets, and Q task processing delay sets are output; based on the Q task processing delay sets and the execution progress of the Q container-level task sets in the target corrected task tree, the timing scheduling intervals of the Q task execution containers are calculated, and the elastic round-robin container scheduling chain is output.

[0105] It should be noted that the order in which the embodiments of the present application are presented is for illustrative purposes only and does not necessarily represent the superiority or inferiority of the embodiments. Furthermore, the foregoing descriptions of specific embodiments of this specification are provided. Furthermore, the processes depicted in the accompanying drawings do not necessarily require the specific order or sequential sequence shown to achieve the desired results. In certain embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0106] The above description is only a preferred embodiment of the present application and is not intended to limit the present application. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present application should be included in the scope of protection of the present application.

[0107] This specification and drawings are merely illustrative of the present application and are intended to cover any and all modifications, variations, combinations, or equivalents within the scope of this application. Obviously, those skilled in the art may make various modifications and variations to this application without departing from the scope of this application. Thus, this application is intended to include such modifications and variations as fall within the scope of this application and its equivalents.

Claims

1. A method for scheduling and managing reconciliation tasks based on dynamic priority, characterized in that: The method comprises: Aggregate multiple original reconciliation tasks based on the task dependency topology to obtain H hierarchical task trees; Reversely setting a plurality of basic priorities of the plurality of original reconciliation tasks from the H hierarchical task trees; Performing task priority evaluation based on the task attributes of the multiple original reconciliation tasks, and outputting multiple dynamic priorities; Performing hierarchical correction and connection of the H hierarchical task trees according to the priority differences between the multiple basic priorities and the multiple dynamic priorities to obtain a target corrected task tree; According to the container performance, the target correction task tree is divided into Q container-level task sets of Q task execution containers; Analyze the timing scheduling of the Q task execution containers according to the execution progress of the Q container-level task sets in the target modified task tree, and output a flexible round-robin container scheduling chain; Based on the elastic round-robin container scheduling chain, the Q task execution containers are scheduled to perform dynamic scheduling reconciliation of the Q container-level task sets along the descending order of priority of the target modified task tree.

2. A method for scheduling and managing reconciliation tasks based on dynamic priority as claimed in claim 1, characterized in that: Reversely setting a plurality of basic priorities of the plurality of original reconciliation tasks from the H hierarchical task trees, the method comprising: Preset task type weight set; Retrieving a plurality of basic task weights of the plurality of original reconciliation tasks from the task type weight set based on the task type; Extracting multiple task hierarchical positions of the multiple original reconciliation tasks from the H hierarchical task trees; The multiple basic priorities of the multiple original reconciliation tasks are set according to the multiple basic task weights and multiple task hierarchical positions.

3. A method for scheduling and managing reconciliation tasks based on dynamic priority as claimed in claim 2, characterized in that: According to container performance, the target correction task tree is divided into Q container-level task sets of Q task execution containers, and the method includes: Initializing Q container performance matrices according to the Q container performance data reported by the Q task execution containers; Extracting the average number of parallel tasks from the Q container performance data, and calculating the subtree partitioning scale according to the task tree level depth and the average number of parallel tasks; Using the subtree segmentation scale, segmenting the target correction task tree from the root node to obtain multiple segmentation subtrees; The Q container efficiency matrices are used to traverse the multiple partition subtrees, and load balancing of tasks across containers is performed to obtain the Q container-level task sets.

4. A method for scheduling and managing reconciliation tasks based on dynamic priority as claimed in claim 3, characterized in that: The Q container efficiency matrices are used to traverse the multiple partition subtrees to perform cross-container load balancing distribution of tasks to obtain the Q container-level task sets. The method includes: Using the first container efficiency matrix to traverse the first partition subtree, matching task types with task parallel requirements; If the task type adaptation result is set to 1 and the task parallel requirement adaptation result is set to 1, the first container adaptation degree is output based on the task processing delay quantification; Similarly, after obtaining the Q container fitnesses, the Q container fitnesses are sorted in ascending order, so as to extract the top O task execution containers from the Q task execution containers according to the sorting result to form a first group of candidate containers; Similarly, the Q container efficiency matrices are used to traverse the multiple partition subtrees, and tasks are allocated across containers to obtain multiple groups of candidate containers. Perform load balancing and distribution screening on the multiple groups of candidate containers to obtain multiple target task containers; According to the multiple target task containers, the multiple partition subtrees are aggregated to obtain the Q container-level task sets.

5. The method for scheduling and managing reconciliation tasks based on dynamic priority as claimed in claim 3, characterized in that: The container performance data includes a task type adaptation list, a task processing delay list, and a maximum number of parallel tasks.

6. The method for scheduling and managing reconciliation tasks based on dynamic priority as claimed in claim 1, characterized in that: Performing task priority evaluation based on the task attributes of the multiple original reconciliation tasks and outputting multiple dynamic priorities, the method comprising: Extracting a first timeliness indicator set of the first original reconciliation task, and quantifying and outputting a first timeliness score based on the first timeliness indicator set; Performing amount weight grading according to the task amount range in which the first original reconciliation task falls, and setting a first amount weight; locally calling the first task execution success rate according to the task type of the first original reconciliation task; The first timeliness score, the first amount weight, and the first task execution success rate are input into a dynamic priority evaluation model for linear weighting to output a first dynamic priority.

7. The method for scheduling and managing reconciliation tasks based on dynamic priority as claimed in claim 1, characterized in that: Performing hierarchical correction and connection of the three hierarchical task trees according to the priority differences between the multiple basic priorities and the multiple dynamic priorities to obtain a target corrected task tree, the method comprising: Preset priority difference scale; According to the P basic priorities and P dynamic priorities of the P task nodes in the first hierarchical task tree, calculate and output P priority difference rates; Locating T nodes to be corrected in the first hierarchical task tree according to whether the P priority difference rates meet the priority difference standard; Arrange the T nodes to be corrected in ascending order of priority to obtain a sequence of nodes to be corrected; According to the sequence of nodes to be corrected, along the first hierarchical task tree, the T nodes to be corrected are subjected to peer node priority balancing and parent node priority inheritance processing one by one to obtain a first hierarchical correction tree; Similarly, the levels of the H hierarchical task trees are modified according to the priority differences between the multiple basic priorities and the multiple dynamic priorities, and H hierarchical modified trees are output; The target correction task tree is constructed by constructing virtual dependencies to connect the H-level correction trees.

8. A method for scheduling and managing reconciliation tasks based on dynamic priority as claimed in claim 7, characterized in that: By constructing virtual dependencies to connect the H-level correction trees, the target correction task tree is constructed, and the method includes: Filter out H root nodes and H groups of leaf nodes from the H hierarchical modified trees; Constructing H virtual dependency features of the H hierarchical correction trees according to the dynamic priorities of the H root nodes and the H groups of leaf nodes; According to the H virtual dependency features, the H hierarchical correction trees are connected to complete the construction of the target correction task tree.

9. The method for scheduling and managing reconciliation tasks based on dynamic priority as claimed in claim 5, characterized in that: According to the execution progress of the Q container-level task sets in the target modified task tree, a timing scheduling analysis is performed on the Q task execution containers to output a flexible round-robin container scheduling chain, the method comprising: According to the Q task processing delay lists of the Q task execution containers, predict the task processing delay of the Q container-level task sets and output Q task processing delay sets; According to the Q task processing delay sets and the execution progress of the Q container-level task sets in the target modified task tree, the timing scheduling intervals of the Q task execution containers are calculated, and the elastic round-robin container scheduling chain is output.

10. A reconciliation task scheduling and management system based on dynamic priority, characterized in that: The system is used to implement the dynamic priority-based reconciliation task scheduling management method according to any one of claims 1 to 9, and the system includes: The hierarchical task tree acquisition module is used to aggregate multiple original reconciliation tasks according to the task dependency topology to obtain H hierarchical task trees; a priority setting module, configured to reversely set a plurality of basic priorities of the plurality of original reconciliation tasks from the H hierarchical task trees; a dynamic priority output module, configured to evaluate task priorities based on the task attributes of the plurality of original reconciliation tasks and output a plurality of dynamic priorities; A target correction task tree acquisition module is used to perform hierarchical correction connection of the H hierarchical task trees according to the priority differences between the multiple basic priorities and the multiple dynamic priorities to obtain a target correction task tree; a target correction task tree segmentation module, configured to segment the target correction task tree into Q container-level task sets of Q task execution containers according to container performance; a scheduling chain output module, configured to analyze the timing scheduling of the Q task execution containers based on the execution progress of the Q container-level task sets in the target modified task tree, and output a flexible round-robin container scheduling chain; A dynamic scheduling reconciliation module is used to schedule the Q task execution containers based on the elastic round-robin container scheduling chain to perform dynamic scheduling reconciliation of the Q container-level task sets along the descending priority order of the target modified task tree.

Images