A method and system for scheduling and managing reconciliation tasks based on dynamic priority

Abstract

This invention discloses a dynamic priority-based reconciliation task scheduling and management method and system, belonging to the field of task scheduling and management technology. The method includes: aggregating multiple original reconciliation tasks according to task dependency topology; setting multiple basic priorities for the original reconciliation tasks; outputting multiple dynamic priorities; performing hierarchical correction and connection of a hierarchical task tree to obtain a target correction task tree; segmenting the target correction task tree; performing temporal scheduling analysis on Q task execution containers to output a flexible round-robin container scheduling chain; and performing dynamic scheduling of reconciliation. This invention solves the technical problems in existing technologies, such as the lack of dynamic priority consideration in reconciliation task scheduling, low task execution efficiency, and unreasonable resource allocation, leading to long reconciliation times and serious resource waste. It achieves dynamic and efficient priority-based scheduling of reconciliation tasks, improving task execution efficiency and optimizing resource allocation.

Description

Technical Field

[0001] This invention relates to the field of task scheduling and management technology, specifically to a method and system for scheduling and managing reconciliation tasks based on dynamic priority. Background Technology

[0002] In numerous sectors such as finance and e-commerce, reconciliation tasks are crucial for ensuring the accuracy of financial and business data. As business scales up, the number and complexity of original reconciliation tasks surge. Traditional reconciliation task scheduling and management methods often employ fixed priorities or simple sequential execution, failing to dynamically adjust the execution order based on task timeliness, amount, and task type. This easily leads to delays in urgent and important tasks, uneven resource allocation, resulting in low task execution efficiency and significant waste of system resources. Furthermore, existing solutions struggle to effectively handle complex dependencies between tasks and dynamic changes in the execution environment, failing to meet the ever-increasing demands of reconciliation operations.

[0003] Existing technologies suffer from technical problems such as a lack of dynamic priority consideration in reconciliation task scheduling, low task execution efficiency, and unreasonable resource allocation, resulting in time-consuming reconciliation work and serious resource waste. Summary of the Invention

[0004] This application provides a dynamic priority-based reconciliation task scheduling and management method and system to address the technical problems in the prior art, such as the lack of dynamic priority consideration in reconciliation task scheduling, low task execution efficiency, and unreasonable resource allocation, which lead to long reconciliation time and serious resource waste.

[0005] In view of the above problems, this application provides a method and system for scheduling and managing reconciliation tasks based on dynamic priority.

[0006] The first aspect of this application provides a method for scheduling and managing reconciliation tasks based on dynamic priority, the method comprising:

[0007] Multiple original reconciliation tasks are aggregated based on task dependency topology to obtain H hierarchical task trees. Multiple basic priorities for the original reconciliation tasks are then determined by reverse engineering from the H hierarchical task trees. Task priorities are evaluated based on the task attributes of the original reconciliation tasks, outputting multiple dynamic priorities. The H hierarchical task trees are then hierarchically corrected and connected based on the priority differences between the basic and dynamic priorities to obtain a target corrected task tree. Based on container performance, the target corrected task tree is divided into Q container-level task sets for Q task execution containers. The timing of the Q task execution containers is analyzed based on their execution progress in the target corrected task tree, outputting a flexible round-robin container scheduling chain. Based on the flexible round-robin container scheduling chain, the Q task execution containers are scheduled to perform dynamic reconciliation of the Q container-level task sets along the target corrected task tree in descending priority order.

[0008] A second aspect of this application provides a dynamic priority-based reconciliation task scheduling and management system, the system comprising:

[0009] A hierarchical task tree acquisition module is used to aggregate multiple original reconciliation tasks based on task dependency topology to obtain H hierarchical task trees; a priority setting module is used to reverse-engineer 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 based on the priority differences of the multiple basic priorities and the multiple dynamic priorities to obtain the target correction task tree. The system includes a positive task tree; a target-corrected task tree segmentation module, used to segment the target-corrected task tree into Q container-level task sets for Q task execution containers based on container performance; a scheduling chain output module, used to perform time-series scheduling analysis on the Q task execution containers based on the execution progress of the Q container-level task sets in the target-corrected task tree, and output an elastic round-robin container scheduling chain; and a dynamic scheduling reconciliation module, used to schedule the Q task execution containers to perform dynamic scheduling reconciliation of the Q container-level task sets along the target-corrected task tree in descending priority order based on the elastic round-robin container scheduling chain.

[0010] One or more technical solutions provided in this application have at least the following technical effects or advantages:

[0011] Multiple original reconciliation tasks are aggregated based on task dependency topology to obtain H hierarchical task trees. Multiple basic priorities are set for these original reconciliation tasks. Task priority evaluation is performed based on the task attributes of these original reconciliation tasks, outputting multiple dynamic priorities. The H hierarchical task trees are then hierarchically corrected and connected to obtain a target corrected task tree. Based on container performance, the target corrected task tree is divided into Q container-level task sets for Q task execution containers. The timing scheduling of the Q task execution containers is analyzed to output a flexible round-robin container scheduling chain. Based on the flexible round-robin container scheduling chain, the Q task execution containers are scheduled for dynamic reconciliation of the Q container-level task sets in descending priority order of the target corrected task tree. This achieves the technical effect of realizing dynamic and efficient priority-based scheduling of reconciliation tasks, improving task execution efficiency, and optimizing resource allocation. Attached Figure Description

[0012] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0013] Figure 1 A flowchart illustrating a reconciliation task scheduling and management method based on dynamic priority, provided for an embodiment of this application;

[0014] Figure 2 This is a schematic diagram of the structure of a reconciliation task scheduling and management system based on dynamic priority, provided in an embodiment of this application.

[0015] Figure labeling: 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 Implementation

[0016] This application provides a dynamic priority-based reconciliation task scheduling and management method and system to address the technical problems in existing technologies, such as the lack of dynamic priority consideration in reconciliation task scheduling, low task execution efficiency, and unreasonable resource allocation, which lead to long reconciliation times and serious resource waste.

[0017] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. All other embodiments obtained by those skilled in the art based on the embodiments of this application without creative effort are within the scope of protection of this application.

[0018] Example 1, as Figure 1 As shown, this application provides a reconciliation task scheduling and management method based on dynamic priority, the method comprising:

[0019] Step S100: Aggregate multiple original reconciliation tasks according to the task dependency topology to obtain H hierarchical task trees.

[0020] Specifically, the process begins by obtaining a set of original reconciliation tasks, each with a specific task identifier and content. The task dependency topology is modeled using a directed acyclic graph (DAG), where nodes represent original reconciliation tasks and directed edges represent dependencies between tasks. For example, if a directed edge exists from node A to node B, task A is a prerequisite for task B, and task B can only start after task A is completed. The strongly connected component algorithm and topological sorting algorithm from graph theory are then used to analyze the task dependency topology. The strongly connected component algorithm identifies strongly connected components in the task dependency topology, grouping interdependent tasks into the same set, which forms the basis of the potential hierarchical task tree. Next, the topological sorting algorithm sorts the tasks within each strongly connected component to determine the execution order. During the aggregation process, related tasks are progressively 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 between nodes reflects the execution order of tasks, with lower-level tasks being prerequisites for higher-level tasks. In this way, H hierarchical task trees are ultimately 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.

[0021] Step S200: Determine the basic priorities of the multiple original reconciliation tasks by working backward from the H hierarchical task trees.

[0022] Specifically, firstly, a pre-defined set of task type weights is established. This 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 transaction verification tasks. For each original reconciliation task, the corresponding basic task weight is retrieved from the task type weight set based on its task type. Simultaneously, the task level position of each original reconciliation task is extracted from H hierarchical task trees. The level position reflects the execution order of tasks within the task tree; lower-level tasks are typically prerequisite tasks with smaller level position values, while higher-level tasks depend on lower-level tasks and have larger level position values. Next, the basic task weights and task level positions are calculated using a weighted summation formula, assigning different coefficients to each. The calculation results are used to set the basic priority for multiple original reconciliation tasks. This basic priority provides an initial basis for subsequent priority adjustments based on dynamic task attributes and task scheduling, ensuring that task scheduling has a reasonable execution order framework from the fundamental level.

[0023] Step S300: Evaluate the task priority based on the task attributes of the multiple original reconciliation tasks, and output multiple dynamic priorities.

[0024] Specifically, after setting the basic priorities, the system dynamically evaluates the priorities of the original reconciliation tasks based on their task attributes, resulting in multiple dynamic priorities. For each original reconciliation task, key task attributes are extracted. First, a set of timeliness indicators is established, encompassing information such as the task's required completion deadline and data update frequency. Based on these indicators, a first timeliness score is calculated using pre-defined quantitative rules; for example, the more urgent the task completion deadline and the more frequent the data updates, the higher the timeliness score. Next, the task's monetary value is weighted according to the range of amounts involved. Task amounts are divided into different tiers, such as small, medium, and large, each with a different monetary weight. Tasks with higher monetary values ​​have a larger weight, highlighting the importance of high-value tasks. Then, based on the task type, historical execution success rate data for that type of task is retrieved from locally stored historical data. This data reflects the reliability of that type of task in past executions. Finally, the first timeliness score, first monetary weight, and first task execution success rate are input into a pre-built dynamic priority evaluation model. This model is based on a linear weighted algorithm, assigning specific weight coefficients to each input factor. These coefficients are set according to the importance of task attributes in influencing priority. Through weighted calculation, the final output is the first dynamic priority corresponding to each original reconciliation task. This dynamic priority evaluation mechanism fully considers the real-time attributes of the tasks, allowing task priorities to change flexibly according to the actual situation, providing a precise basis for more reasonable task scheduling in the future.

[0025] Step S400: Based on the priority differences of the multiple basic priorities and multiple dynamic priorities, perform hierarchical correction and connection of the H hierarchical task trees to obtain the target corrected task tree.

[0026] Specifically, after obtaining the basic and dynamic priorities of multiple original reconciliation tasks, the hierarchy of H hierarchical task trees is corrected and connected based on the priority differences between the two to obtain the target corrected task tree. First, a priority difference scale is preset, which serves as the standard for judging whether the task priority differences are significant; this scale is determined through empirical values ​​or simulation tests. For P task nodes in the first hierarchical task tree, their basic and dynamic priorities are obtained, and the priority difference rate of each node is calculated to quantify the degree of priority difference. Based on the comparison between 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 differences of these nodes exceed a reasonable range, requiring adjustment of their hierarchical position in the task tree. These T nodes to be corrected are arranged in ascending priority order to generate a sequence of nodes to be corrected. Subsequently, along the first hierarchical task tree, priority balancing of sibling nodes and priority inheritance of parent nodes are performed sequentially on the T nodes to be corrected in the sequence. In the priority balancing process for peer nodes, the order of peer nodes is adjusted according to priority differences to ensure that higher-priority nodes are placed earlier, thus optimizing the task execution order. In the priority inheritance process for parent nodes, the priority adjustment of child nodes is ensured to conform to the priority logic of their parent nodes, maintaining the overall structural rationality of the task tree, thereby obtaining the first-level correction tree. Following the same processing flow, the above-mentioned hierarchical correction operations are performed on each of the H hierarchical task trees, ultimately outputting H hierarchical correction trees. To construct the complete target correction task tree, H root nodes and H groups of leaf nodes are selected from the H hierarchical correction trees, and H virtual dependency features are constructed based on the dynamic priorities of these nodes. Virtual dependency features reflect the logical relationships between different hierarchical correction trees. Based on these virtual dependency features, the H hierarchical correction trees are logically connected to complete the construction of the target correction task tree. This target correction task tree comprehensively considers the basic and dynamic priorities of the tasks, resulting in a more scientific and reasonable hierarchical structure, laying a solid foundation for the efficient scheduling of subsequent tasks.

[0027] Step S500: Based on container performance, divide the target correction task tree into Q container-level task sets of Q task execution containers.

[0028] Specifically, after constructing the target correction task tree, it is rationally divided into Q container-level task sets for Q task execution containers. First, each of the Q task execution containers reports container performance data containing 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 to more intuitively represent the processing capabilities of each container for different tasks in matrix form. Next, the average number of parallel tasks is extracted from the Q container performance data, and the subtree partitioning scale is calculated in conjunction with the task tree hierarchy depth. The task tree hierarchy depth reflects the complexity of the task tree, and the average number of parallel tasks reflects the overall parallel processing capability of the container. Combining these two factors determines an appropriate partitioning granularity, ensuring that the partitioned subtrees fully utilize container resources while facilitating management and allocation. Then, using the calculated subtree partitioning scale, partitioning begins from the root node of the target correction task tree, resulting in multiple partitioned subtrees. To achieve rational task allocation, these partitioned subtrees are traversed using the Q container performance matrices. Taking the traversal of the first subtree of the first container performance matrix as an example, the task type and task parallelism requirement are matched. If the task type fit result is set to 1 (indicating that the container can handle the task type) and the task parallelism requirement fit result is set to 1 (indicating that the container can meet the parallel processing requirements of the task), then the first container fit degree is output based on the task processing latency quantization. This fit degree reflects the suitability of the container for handling the task. The above operation is repeated for all containers and subtrees to obtain Q container fit degrees, which are then sorted in ascending order. Based on the sorting result, the top O task execution containers are extracted from the Q task execution containers to form the first group of candidate containers. This process is repeated to perform task cross-container allocation on multiple subtrees, resulting in multiple groups of candidate containers. Finally, load balancing allocation is performed on the multiple groups of candidate containers. Taking into account factors such as container load and task execution efficiency, multiple target task containers are determined. The subtrees of the corresponding target task containers are aggregated to finally obtain the container-level task sets of each of the Q task execution containers, realizing the reasonable allocation of tasks among different containers and improving the overall processing efficiency of the system.

[0029] Step S600: Based on the execution progress of the Q container-level task sets in the target correction task tree, perform time-series scheduling analysis on the Q task execution containers and output an elastic round-robin container scheduling chain.

[0030] Specifically, after dividing the target correction task tree into Q container-level task sets (Q task execution containers), efficient time-series scheduling analysis is performed on the Q task execution containers to output a flexible round-robin container scheduling chain to optimize task execution efficiency. First, a task processing latency list is 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 current container load, a set of Q task processing latency is 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 correction task tree is monitored in real time to determine the current execution stage of each task. Combining the task processing latency set and execution progress information, the time-series scheduling interval for the Q task execution containers is calculated. For each container, the time interval for the next task execution call is dynamically determined based on the completion status of its executed tasks, the expected processing time of remaining tasks, and the execution status of other containers. During the calculation process, high-priority tasks are prioritized for execution. For containers handling high-priority tasks, their scheduling intervals are appropriately shortened to allow them to process subsequent tasks more quickly. Conversely, for containers handling low-priority tasks and currently under high load, the scheduling intervals are appropriately extended to balance the allocation of system resources. This calculation method generates a flexible, round-robin container scheduling chain. Within this chain, the same container is allowed to appear repeatedly because different tasks have varying degrees of compatibility with containers; some containers may be better suited to handling specific types of tasks and will 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 different containers, the processing capacity of each container is fully utilized, while the execution order and timing can be flexibly adjusted according to actual conditions. This improves the efficiency and flexibility of the entire reconciliation task scheduling system, ensuring efficient and stable task execution.

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

[0032] Specifically, after obtaining the elastic round-robin container scheduling chain, fine-grained scheduling is performed on Q task execution containers based on this chain, achieving dynamic scheduling reconciliation of the Q container-level task sets in descending order of priority along the target-corrected task tree. The Q task execution containers are invoked sequentially, strictly following the order and time intervals determined by the elastic round-robin container scheduling chain. Each time a container is invoked, tasks are preferentially selected from the container-level task set corresponding to the high-priority task nodes in the target-corrected task tree. Since the target-corrected task tree has undergone hierarchical correction considering both basic and dynamic priorities, its task priorities accurately reflect the urgency and importance of the tasks. During scheduling, the task execution status and container resource usage are continuously monitored. If a high-priority task encounters an anomaly or requires additional resources during execution, the scheduling strategy is dynamically adjusted to prioritize its execution. For example, if a container is found to be short of resources while processing a high-priority task, the execution of some low-priority tasks is paused, and idle resources from other containers are allocated 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, and the container is scheduled to execute the next task ahead of time. If a container malfunctions or experiences performance degradation, it is temporarily removed from the scheduling chain, and the task is reassigned to other available containers, ensuring that task scheduling is not affected. Through this dynamic scheduling method, the task execution process is continuously optimized, the reconciliation of Q container-level task sets is completed efficiently, the accuracy and timeliness of the reconciliation are improved, and the stable and efficient operation of the entire reconciliation task scheduling management system is guaranteed.

[0033] In one possible implementation, step S200 further includes:

[0034] Step S210: Preset task type weight set.

[0035] Step S220: Based on the task type, retrieve the multiple basic task weights of the multiple original reconciliation tasks from the task type weight set.

[0036] Step S230: Extract multiple task level positions of the multiple original reconciliation tasks from the H hierarchical task trees.

[0037] Step S240: Based on the multiple basic task weights and multiple task level positions, set the multiple basic priorities of the multiple original reconciliation tasks.

[0038] Specifically, the first step is to pre-define a weight set for each task type. This weight set is a key reference for setting the overall priority, and its construction is based on a comprehensive consideration of various factors, including the importance and complexity of different types of reconciliation tasks in the business process and their impact on the overall reconciliation results. For example, for reconciliation tasks in the financial industry, those involving core fund transactions are given higher weights because they are directly related to fund security and financial accuracy; while some auxiliary data verification tasks have relatively lower weights.

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

[0040] Extract the task hierarchy position of each of the original reconciliation tasks from the constructed H hierarchical task trees. This task hierarchy position information intuitively reflects the sequential execution order of tasks in the task tree. Tasks at lower levels are usually prerequisites for completing tasks at higher levels, and the hierarchy position is closely related to the task execution order.

[0041] In setting the basic priority of initial reconciliation tasks, two important factors are comprehensively considered: the weights of multiple basic tasks and the hierarchical positions of multiple tasks. Assume there are three initial reconciliation tasks A, B, and C. In the preset task type weight set, task A has a basic task weight of 0.8 (due to its involvement in core business data reconciliation, it is of high importance), task B has a basic task weight of 0.5 (belonging to ordinary business data verification), and task C has a basic task weight of 0.3 (it is an auxiliary data comparison task). From the H hierarchical task tree, we know that task A is at level 2, task B is at level 3, and task C is at level 4. A weighted calculation method is used to set the basic priority. Assume the coefficient assigned to the basic task weight is 0.8, and the coefficient assigned to the task hierarchical position is 0.2 (these two coefficients are set according to the importance ratio of task scheduling). To calculate the basic priority of task A: multiply the basic task weight (0.8) by a coefficient of 0.8 to get 0.64; multiply the task level position (2) by a coefficient of 0.2 to get 0.4. Adding these two together, the basic priority of task A is 1.04. Similarly, the basic priority of task B is 0.5 × 0.8 + 3 × 0.2 = 1, and the basic priority of task C is 0.3 × 0.8 + 4 × 0.2 = 1.04. By combining the basic task weight and the task level position in this calculation method, a reasonable basic priority is set for each original reconciliation task. This ensures that in subsequent task scheduling, tasks like task C, which have low task type weights but are later in the level and are considered preliminary, can be reasonably arranged, while important tasks like task A, which are earlier in the level, will be given priority, ensuring the orderliness and efficiency of the entire reconciliation task scheduling.

[0042] In one possible implementation, step S300 further includes:

[0043] Step S310: Extract the first timeliness indicator set of the first original reconciliation task, and output the first timeliness score based on the first timeliness indicator set.

[0044] Step S320: Based on the task amount range of the first original reconciliation task, perform amount weight classification and set the first amount weight.

[0045] Step S330: Based on the task type of the first original reconciliation task, locally call the first task execution success rate.

[0046] Step S340: Linearly weight the first timeliness score, the first amount weight, and the first task execution success rate into the dynamic priority evaluation model, and output the first dynamic priority.

[0047] Specifically, for the first original reconciliation task, its first timeliness indicator set is extracted. This indicator set mainly includes the task's creation time, deadline, and current time. By obtaining this time information, the remaining processing time of the task is calculated, which is the difference between the deadline and the current time. Then, the remaining processing time is divided by the total time limit (the difference between the deadline and the creation time) to obtain the proportion of the remaining processing time to the total time limit. To convert this proportion into a score that better reflects the task's timeliness, an exponential decay function is applied. The exponential decay function S = Where S is the dependent variable of the function, i.e., the output value, which in this context represents the timeliness score calculated based on the proportion of remaining time. It is a natural constant. This is the decay coefficient, an adjustable parameter. It determines the rate at which the timeliness score decays as a percentage of remaining time changes. The larger the value, the faster the timeliness score S drops as the proportion of remaining time decreases, indicating a more pronounced sense of urgency in the task. The independent variable is R, representing the proportion of remaining processing time to the total time limit, ranging from [0, 1]. The closer R is to 1, the more ample the remaining time; the closer R is to 0, the less remaining time. Under the influence of the exponential decay function, a correlation is established between the remaining time proportion and the timeliness score. When the remaining time proportion is large, it means the task has more time to process, resulting in a lower timeliness score calculated by the function, indicating relatively low urgency. Conversely, when the remaining time proportion is small, i.e., less remaining time, the calculated timeliness score is higher, indicating higher priority and urgency of the task. In this way, the first timeliness score is quantitatively output based on the first timeliness indicator set, providing an important time dimension consideration for subsequent dynamic priority assessment.

[0048] Based on the amount involved in the first original reconciliation task, its corresponding task amount range is determined. These amount ranges are pre-defined, for example, dividing the reconciliation amount into small amounts (e.g., less than 10,000 yuan), medium amounts (10,000 yuan to 100,000 yuan), and large amounts (greater than 100,000 yuan). Different ranges correspond to different weight levels, and the amount weight is graded according to preset rules. If the task amount falls into the large amount range, a higher weight value is assigned; if it falls into the small amount range, a relatively lower weight value is assigned, thus setting the first amount weight to reflect the degree of influence of the task amount on the task priority.

[0049] Based on the task type of the first original reconciliation task, a search is performed in the local storage data. The local storage contains past execution success rate data for different task types, and the corresponding first task's execution success rate is precisely retrieved based on the task type. For example, if the task type is routine account reconciliation, its execution success rate is retrieved from the stored routine account reconciliation task data; if it is a special account reconciliation task, the execution success rate data for special account reconciliation tasks is retrieved. This execution success rate reflects the success rate of this type of task in past executions, providing a historical execution reference for assessing the priority of the current task.

[0050] The previously obtained first timeliness score, first amount weight, and first task execution success rate are input into the dynamic priority evaluation model. This model uses a linear weighted approach, assigning a corresponding weight coefficient to each input value. Assume the weight coefficient for the first timeliness score is w1, the weight coefficient for the first amount weight is w2, and the weight coefficient for the first task execution success rate is w3, and w1 + w2 + w3 = 1. The first dynamic priority is calculated using the formula: First Dynamic Priority = w1 × First Timeliness Score + w2 × First Amount Weight + w3 × First Task Execution Success Rate, ultimately outputting the first dynamic priority. This priority comprehensively considers factors such as the task's time urgency, the amount involved, and historical execution success rates, providing a more scientific and reasonable priority basis for subsequent reconciliation task scheduling, ensuring that important and urgent tasks are processed first.

[0051] In one possible implementation, step S400 further includes:

[0052] Step S410: Preset priority difference scale.

[0053] Step S420: Based on the P basic priorities and P dynamic priorities of the P task nodes in the first-level task tree, calculate and output the P priority difference rates.

[0054] Step S430: Based on whether the P priority difference rates meet the priority difference scale, locate T nodes to be corrected in the first hierarchical task tree.

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

[0056] Step S450: Based on the sequence of nodes to be corrected, perform priority balancing of sibling nodes and priority inheritance of parent nodes on each of the T nodes to be corrected along the first hierarchical task tree to obtain the first hierarchical correction tree.

[0057] Step S460: By analogy, perform hierarchical correction on the H hierarchical task trees according to the priority differences of the multiple basic priorities and multiple dynamic priorities, and output H hierarchical correction trees.

[0058] Step S470: By constructing virtual dependencies to connect the H hierarchical correction trees, the construction of the target correction task tree is completed.

[0059] Specifically, a priority difference scale needs to be preset, which is the core basis for determining whether the priority of task nodes needs to be adjusted. This scale includes two key thresholds: the absolute difference threshold ΔP between dynamic priority and base priority, and the relative difference rate threshold δ%. System administrators determine these two thresholds based on business needs, task characteristics, and past task scheduling experience. The absolute difference threshold ΔP directly measures the numerical difference between dynamic priority and base priority. For example, if ΔP is set to 3, when the difference between the dynamic priority and base priority of a task node is greater than 3, it indicates that the priority of that node has changed significantly. This setting helps to quickly identify task nodes with prominent priority changes, providing a clear target for subsequent adjustments. The relative difference rate threshold δ% reflects the degree of priority change more accurately from a proportional perspective. Assuming δ% is set to 15%, if the change in the dynamic priority of a task node compared to its base priority exceeds 15%, then that node will be included in the subsequent evaluation scope. The relative difference rate threshold considers the differences in base priorities of different task nodes, avoiding situations that might be overlooked when judging solely based on absolute differences. For example, consider two task nodes. One has a lower base priority, so its absolute difference may change small, but its relative change may be larger. The other has a higher base priority, so its absolute difference may change significantly, but its relative change may not be as pronounced. By using these two thresholds in combination, we can comprehensively and meticulously filter out task nodes that need priority adjustment, laying a solid foundation for subsequent optimization of the task tree's hierarchical structure.

[0060] For each of the P task nodes in the first-level task tree, the system obtains the base priority and dynamic priority of each node and calculates the difference rate between them. The P priority difference rates are obtained by calculating (dynamic priority - base priority) ÷ base priority × 100% (when the base priority is not 0). These difference rates reflect the degree of deviation between the dynamic priority and the base priority of each task node.

[0061] The P priority difference rates are compared with a preset priority difference scale. If the priority difference rate of a task node exceeds ΔP in absolute value or δ% in relative value, the node is determined to be a node that needs correction. After screening, T such nodes to be corrected are located in the first-level task tree. These nodes are the key targets for subsequent adjustments.

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

[0063] Based on the sorted sequence of nodes to be corrected, operations are performed on these T nodes sequentially. For each node, priority balancing of sibling nodes is performed first. This process comprehensively considers the task characteristics of the node and its sibling nodes, such as urgency, importance, and resource requirements. By adjusting their priority values, the priority distribution of nodes at the same level is made more reasonable, avoiding situations where a node's priority is too high or too low, affecting the overall task scheduling efficiency. Next, parent node priority inheritance is performed. The priority characteristics of the parent node of the node to be corrected are analyzed, and the parent node's priority attributes are passed to the node to be corrected according to certain rules. For example, if the parent node has a high priority, it means that its subtasks also have high importance, so the node to be corrected will inherit the corresponding priority increase; conversely, if the parent node has a low priority, the priority of the node to be corrected may also be appropriately reduced. This process of balancing sibling node priorities and inheriting parent node priorities for each node to be corrected is repeated until all T nodes have been processed. After this series of processes, the structure and node priorities of the first-level task tree were optimized and adjusted, ultimately resulting in the first-level modified tree, which provides strong support for more efficient task scheduling and execution in the future.

[0064] 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, H hierarchical correction trees are output, so that each hierarchical task tree can be optimized according to the difference between dynamic priority and basic priority.

[0065] After obtaining H hierarchical correction trees, these trees 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 requirements of the business process are analyzed to construct virtual dependencies. Virtual dependencies are not actual task execution dependencies, but rather artificially created relationships to connect different hierarchical correction trees. Key nodes in 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 order, 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 built between these two nodes. By constructing a series of such virtual dependencies, the scattered H hierarchical correction trees are gradually connected to form an organic whole. With all the necessary virtual dependencies built, the originally independent H hierarchical correction trees are tightly linked, ultimately completing the construction of the target correction task tree.

[0066] In one possible implementation, step S470 further includes:

[0067] Step S471: Select H root nodes and H groups of leaf nodes from the H level correction trees.

[0068] Step S472: Based on the dynamic priorities of the H root nodes and H groups of leaf nodes, construct H virtual dependency features of the H hierarchical correction trees.

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

[0070] Specifically, a comprehensive analysis of the H hierarchical correction trees is conducted. For each hierarchical correction tree, its root node (i.e., the starting node without a parent node) and leaf nodes (i.e., the ending node without children nodes) are accurately identified and selected. This step is the foundation for subsequent virtual dependency construction. By extracting these key nodes, preparations are made for establishing connections between the hierarchical correction trees. For example, the root node of hierarchical correction tree A is task A1, and the leaf nodes include tasks A5, A8, etc. This information is recorded, and the same operation is performed on all H hierarchical correction trees to obtain H root nodes and H sets of leaf nodes.

[0071] Virtual dependency features are constructed based on the dynamic priorities of the selected H root nodes and H groups of leaf nodes. Dynamic priority reflects the importance and urgency of tasks. The differences in dynamic priorities between root and leaf nodes at different levels of the correction tree are analyzed. If the root node of one level of correction tree has a higher dynamic priority, while the leaf nodes of another level have lower dynamic priorities, and they have a potential connection in business logic, a virtual dependency feature is constructed based on this priority relationship and business logic. This could involve setting a connection rule so that the level of correction tree containing the higher-priority root node takes precedence over the level of correction tree containing the lower-priority leaf node in task execution order, or establishing a virtual path for data transfer. By performing this analysis and rule setting for each group of root and leaf nodes, H virtual dependency features are constructed for each of the H level correction trees.

[0072] H hierarchical correction trees are connected based on H pre-constructed virtual dependency features. Following the rules and relationships defined by these virtual dependency features, the correction trees are linked together. For example, based on the execution order and data transfer path determined by the virtual dependency features, nodes in different correction trees are connected in an orderly manner, allowing tasks to be executed sequentially and data to be transferred smoothly between different correction trees. Once all 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 level of correction tree, while also considering task priority and logical relationships, providing an efficient and rational overall framework for subsequent task scheduling and execution.

[0073] In one possible implementation, step S500 further includes:

[0074] Step S510: Initialize Q container performance matrices based on the Q container performance data reported by the Q task execution containers.

[0075] Step S520: Extract the average number of parallel tasks from the Q container performance data, and calculate the subtree segmentation scale based on the task tree level depth and the average number of parallel tasks.

[0076] Step S530: Using the subtree segmentation scale, segment the target correction task tree from the root node to obtain multiple segmented subtrees.

[0077] Step S540: Use the Q container performance matrices to traverse the multiple segmentation subtrees and perform cross-container load balancing of tasks to obtain the Q container-level task sets.

[0078] Specifically, during the process of rationally allocating the target correction task tree to Q task execution containers, each of the Q task execution containers reports its own container performance data in real time. This data includes a task type adaptation list, a task processing latency list, and a maximum number of parallel tasks. Upon receiving this data, each task execution container is processed separately. Taking one container as an example, based on its reported task type adaptation list, the types of reconciliation tasks that the container can handle are determined, 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 into the corresponding positions in the matrix, reflecting the time required for the container to process each task. The maximum number of parallel tasks may be represented in a specific region of the matrix by a specific identifier or value, used to characterize the container's parallel processing capability. In the same way, matrices are constructed for each of the Q task execution containers, ultimately initializing to obtain Q container performance matrices. These matrices provide an intuitive and systematic data foundation for subsequent analysis of the containers' processing capabilities for different tasks, calculation of subtree partitioning scales, and cross-container load balancing of tasks, and are an important prerequisite for achieving efficient task allocation and scheduling.

[0079] First, iterate through the Q container performance data points, extracting the maximum number of parallel tasks for each task execution container. Obtain the Q maximum number of parallel tasks, sum these Q maximum number of parallel tasks, and divide by the number of containers Q to obtain the average number of tasks, denoted as . In this way, the average number of parallel tasks for Q containers can be obtained. This mean represents the average level of parallel task processing capability of these containers as a whole. Simultaneously, the depth D of the target modified task tree is obtained. This depth reflects the complexity of the task tree; the deeper the level, the more complex the dependencies and execution logic between tasks tend to be. Next, a weighted algorithm is used to calculate the subtree partitioning scale S. Weights are assigned to the average number of parallel tasks and the depth of the task tree. and And satisfy + =1. The allocation of these two weights depends on the emphasis placed on container parallel processing capabilities and task tree complexity in the actual business scenario. If more emphasis is placed on container parallel processing capabilities, the weight can be increased. If more emphasis is placed on the complexity of the task tree, then increase... Finally, the formula for calculating the subtree splitting scale S is S= × + ×D. When segmenting the target correction task tree, the segmentation scale must meet the following requirements: the number of tasks in the resulting subtree must be between 0.5 and 1.5 times the average number of parallel tasks to avoid wasting container resources or task blocking; the depth of the subtree's hierarchy must not exceed the segmentation scale calculated using a weighted algorithm (S= × + ×D), ensuring that the complexity of task dependencies is within a reasonable range; all prerequisite tasks of tasks within a subtree must be completely contained within that subtree to prevent task chain breaks; the standard deviation of the number of tasks in all subtrees must be controlled within 0.3 times the average number of parallel tasks to ensure load balancing among containers; when the subtree task density (the ratio of the number of tasks to the level depth) exceeds 2, the weight of the average number of parallel tasks is automatically increased and the partitioning scale is recalculated to adapt to the processing needs of task-intensive branches. These multi-dimensional standards ensure that the partitioning operation is scientific, reasonable, and executable. The subtree partitioning scale obtained through this weighted algorithm fully combines the parallel processing capabilities of the containers and the structural characteristics of the task tree, providing a scientific basis for subsequent reasonable partitioning of the task tree and achieving efficient task allocation among Q task execution containers.

[0080] After obtaining the subtree partitioning scale, the partitioning process begins from the root node of the target correction task tree. The subtree partitioning scale defines the standards for partitioning subtrees in terms of the number of tasks, the span of task levels, etc. Starting from the root node, based on the subtree partitioning scale, it is first determined whether the task set consisting of the root node and its child nodes meets the partitioning scale requirements. If it does, this part of the task set is divided into a partitioned subtree; if not, it is further expanded downwards, incorporating the child nodes of the next level, until the standards specified by the partitioning scale are met. In this process, the dependencies between tasks are fully considered to ensure that the tasks in each partitioned subtree are coherent and logically complete, avoiding situations where a task cannot be executed independently due to partitioning. As the partitioning operation continues, it is continuously partitioned layer by layer from the root node until the entire target correction task tree is partitioned, ultimately resulting in multiple partitioned subtrees. In subsequent task scheduling, these partitioned subtrees will be used as independent task units and allocated to Q task execution containers, thereby achieving parallel processing and reasonable allocation of tasks and improving overall task processing efficiency.

[0081] The first subtree is traversed using the first container performance matrix. For each task in the subtree, the task type and parallel processing requirements are matched with the container. If the task type matches successfully, the matching result is set to 1. Simultaneously, the parallel processing requirement also matches successfully and is set to 1. At this point, the task processing latency of the container is quantified, and the first container fit score is output. Following the same method, the first subtree is traversed using Q container performance matrices to obtain Q container fit scores. These Q container fit scores are then sorted in ascending order. Based on the sorting result, the top O task execution containers are extracted from the Q task execution containers to form the first group of candidate containers. Next, the above process is repeated for the remaining subtrees. Each subtree is traversed sequentially using Q container performance matrices, and after matching task type and parallel processing requirements, fit score calculation, and sorting, multiple groups of candidate containers are obtained. Finally, load balancing and allocation are performed on these multiple groups of candidate containers. Factors such as the current load and processing capacity of each container are comprehensively considered to avoid situations where a container is overloaded or underloaded, thus selecting multiple target task containers. Finally, based on the identified target task containers, the corresponding subtrees are aggregated. The subtrees corresponding to each target task container are aggregated together to form Q container-level task sets, achieving a reasonable distribution of tasks among the Q task execution containers and realizing cross-container load balancing of tasks.

[0082] In one possible implementation, step S510 further includes:

[0083] Step S511: The container performance data includes a task type adaptation list, a task processing latency list, and a maximum number of parallel tasks.

[0084] Specifically, container performance data consists of three core components. The task type compatibility list details the various tasks the container can handle, clearly indicating its support for different business task types (such as data computation, file transfer, and logical judgment). This list allows for a direct assessment of 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 its efficiency; shorter latency means faster task processing. The maximum number of parallel tasks indicates the maximum number of tasks the container can process concurrently, reflecting its parallel processing capabilities. A higher value indicates stronger performance in multi-task concurrent processing. These three components together constitute container performance data, providing crucial references for subsequent tasks such as task allocation and subtree partitioning scale calculation, helping to comprehensively evaluate the container's task processing capabilities and adaptability.

[0085] In one possible implementation, step S540 further includes:

[0086] Step S541: Use the first container performance matrix to traverse the first segmentation subtree and match the task type and task parallelism requirements.

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

[0088] Step S543: By analogy, after obtaining Q container fit scores, the Q container fit scores 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 results, forming the first group of candidate containers.

[0089] Step S544: By analogy, the multiple segmentation subtrees are traversed using the Q container performance matrices to perform task cross-container allocation and obtain multiple sets of candidate containers.

[0090] Step S545: Perform load balancing distribution screening on the multiple groups of candidate containers to obtain multiple target task containers.

[0091] Step S546: Based on the multiple target task containers, aggregate the multiple segmented subtrees to obtain the Q container-level task sets.

[0092] Specifically, task allocation and matching are performed to extract the first container performance matrix. This matrix contains data such as the first task execution container's adaptability to different task types, task processing latency, and maximum number of parallel tasks. This matrix is ​​then applied to the first segmented subtree, and each task in the subtree is analyzed in detail. For each task, its task type is examined and compared with the task types that the first container can handle, as recorded in the matrix, to determine if the container has the capability to process this task type. Simultaneously, the parallel requirements of the task are considered—whether the task needs to be executed concurrently with other tasks and the required amount of parallel resources—and these requirements are matched with the maximum number of parallel tasks in the first container in the matrix. In this way, the adaptability of the first container to each task within the first segmented subtree in terms of task type and parallel requirements can be clearly defined.

[0093] If the task type fit result is 1 and the task parallelism requirement fit result is also 1, the following algorithm will be used to quantify and output the first container fit degree. First, assume there are n tasks in the first subtree. For the i-th task, its processing latency is obtained from the first container performance matrix as t. i And pre-set the weight of each task to w based on its importance. i And satisfy =1. Calculate the weighted sum of task processing delays, T= ×t iThis step comprehensively considers the importance of different tasks and their processing latency. Then, a baseline latency value T0 is introduced, which is an ideal processing latency value determined based on historical experience, system performance standards, etc. This is expressed by the formula A= The fitness score A of the first container is calculated. The larger the value of A, the longer the actual latency of the first container in processing the task of splitting the subtree is relative to the baseline latency, and the lower the fitness score. Conversely, the closer the value of A is to 1 or even less than 1, the higher the efficiency of the first container in processing these tasks, and the higher the fitness score. Through this algorithm, a quantitative fitness score of the first container can be obtained, providing an accurate reference indicator for subsequent task allocation.

[0094] Following the same process, the first subtree is traversed sequentially through the Q container performance matrices to obtain Q container fit scores. These fit 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 group of candidate containers. This sorting and filtering method prioritizes containers with high fit scores, providing a better selection for task allocation.

[0095] Following the same approach as processing the first subtree, each of the remaining subtrees is traversed sequentially using Q container performance matrices. For each new subtree, task type and task parallelism requirements are matched. If a match is successful (i.e., both task type and task parallelism requirements are set to 1), the fit of each container to that subtree is output based on task processing latency quantization, resulting in Q container fits. These Q container fits 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 result, forming a set of candidate containers for that subtree. By repeatedly performing this process for multiple subtrees, multiple sets of candidate containers are obtained. These multiple sets of candidate containers cover the container combinations with high fit for each subtree, providing a rich selection basis for achieving cross-container load balancing of tasks.

[0096] After obtaining multiple candidate containers, a detailed evaluation system is constructed, collecting key information for each candidate container, such as current CPU utilization, memory usage, number of assigned tasks, average processing latency, historical throughput, and maximum number of parallel processing tasks. Next, these metrics are quantified and normalized to eliminate differences in units. The metrics for candidate containers are divided into two categories: metrics such as CPU utilization and memory usage, where lower values ​​are better, are represented by a scale of 1 to 1. Converting to metrics like scores and historical throughput, where higher values ​​are generally better, is straightforward. The process involves transformation, followed by assigning appropriate weights to each indicator based on business needs and system characteristics. A weighted average algorithm is then used to calculate the comprehensive score of each candidate container. When allocating tasks, the selection process proceeds sequentially from candidate containers with high comprehensive scores, based on the task characteristics of the segmented subtrees, such as task type, estimated execution time, and parallelism requirements. Each selection checks whether the container's remaining processing capacity can meet the task requirements of the segmented subtree; if not, the container is skipped and the next one is selected. Simultaneously, a dynamic monitoring and adjustment mechanism is employed, updating the load information of each container in real time during the allocation process. After allocating a certain number of segmented subtrees, the comprehensive score of each container is recalculated, dynamically optimizing subsequent allocations. Furthermore, to avoid single points of failure and excessive resource concentration, limiting rules are set, such as distributing the same type of critical tasks across different containers and controlling the maximum number of tasks a single container can handle. Through this comprehensive, dynamic, and reasonable screening and allocation process, multiple target task containers are determined from multiple groups of candidate containers, achieving load balancing and improving overall operational efficiency and stability.

[0097] Multiple subtrees are aggregated around these containers to form Q container-level task sets. A mapping relationship is established to associate each subtree with its corresponding target task container. For subtrees already assigned to the same target task container, they are merged according to certain rules. For example, based on the execution order and dependencies of tasks, logically coherent subtrees are integrated to ensure that tasks within the same container can be executed efficiently and orderly. During the aggregation process, the task sets are optimized and adjusted, removing duplicate or redundant tasks and further clarifying the dependencies between tasks, making each container-level task set a complete and independent set of tasks. With the aggregation operation completed, the originally scattered subtrees are integrated into Q target task containers, forming Q container-level task sets. These task sets will serve as the basic units for subsequent task execution, providing a clear task execution plan for each task execution container, realizing the reasonable division of tasks among different containers, and ensuring the efficient and stable operation of the entire task scheduling.

[0098] In one possible implementation, step S600 further includes:

[0099] Step S610: Based on the Q task processing latency list of the Q task execution containers, perform task processing latency prediction on the Q container-level task sets, and output the Q task processing latency sets.

[0100] Step S620: Based on the processing delay set of the Q tasks and the execution progress of the Q container-level task set in the target correction task tree, calculate the timing scheduling interval of the Q task execution containers and output the elastic round-robin container scheduling chain.

[0101] Specifically, a Long Short-Term Memory (LSTM) network is used to predict the processing latency of Q container-level task sets, thus outputting Q task processing latency sets. LSTM is a special type of recurrent neural network that excels at processing time-series data and can effectively capture 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 time-series format data as training data. The task processing latency list of each container contains historical latency data for multiple time steps, as well as corresponding feature information such as task type and number of tasks. This data is normalized to map values ​​of different ranges to the same interval, improving the model training effect. Then, an LSTM model is constructed. The model contains an input layer, multiple LSTM layers, and an output layer. The input layer receives preprocessed data, the LSTM layers are responsible for learning the time-series features and long-term dependencies in the data, and the memory units update their own state based on the input information and previous states, selectively forgetting and retaining information. By stacking multiple LSTM layers, more complex features can be extracted. Finally, the model is trained using the organized training data. During training, the model's parameters, such as weights and biases, are continuously adjusted using the backpropagation algorithm to minimize the error between the predicted results and the actual latency. A common loss function is the mean squared error loss function. Training continues for multiple rounds until the model's loss value converges to a small range, indicating that the model has achieved good training results. After training, relevant data (task type, quantity, etc.) for Q container-level task sets are 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 latency.

[0102] Based on the obtained Q task processing latency sets and the execution progress of Q container-level task sets in the target revised task tree, the working rhythm of task execution containers is carefully planned to generate an elastic 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 each task set has completed and what the completion percentage is. Simultaneously, combined with the corresponding task processing latency sets, the estimated time required for each task execution container to complete the remaining tasks is determined. Taking containers A and B as examples, if container A's task processing latency set shows an estimated processing time of Ta for the current task set, and 30% of the tasks in the target revised task tree have been completed, then the estimated processing time for the remaining tasks is 0.7Ta; container B's task processing latency set shows an estimated processing time of Tb for its task set, and 20% has been completed, with a remaining estimated time of 0.8Tb. Taking into account this information and factors such as task dependencies, the timing scheduling interval between containers is calculated. If some tasks in container B depend on the output of container A to execute, then container B's startup time must be after container A has completed its relevant task output. The scheduling interval between them is the remaining time for container A to complete its relevant tasks. During the calculation, potential changes in task processing latency in real-world scenarios are fully considered. For example, unforeseen circumstances might slow down the processing speed of a container, or the addition of new tasks could impact the overall scheduling. Therefore, the scheduling interval is dynamically adjusted. Based on these calculations, a flexible round-robin container scheduling chain is generated. In this chain, the same container is allowed to appear repeatedly. This is because in complex task systems, a container may need to participate in the processing of tasks at different stages multiple times. Furthermore, 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.

[0103] Example 2 is based on the same inventive concept as the dynamic priority-based reconciliation task scheduling and management method in the previous examples, such as... Figure 2 As shown, this application provides a reconciliation task scheduling and management system based on dynamic priority. The system and method embodiments in this application are based on the same inventive concept. The system includes:

[0104] 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.

[0105] The priority setting module 20 is used to set multiple basic priorities of the multiple original reconciliation tasks by reverse derivation from the H hierarchical task trees.

[0106] The dynamic priority output module 30 is used to evaluate the task priority based on the task attributes of the multiple original reconciliation tasks and output multiple dynamic priorities.

[0107] The target correction task tree acquisition module 40 is used to perform hierarchical correction and connection of the H hierarchical task trees according to the priority differences of the multiple basic priorities and multiple dynamic priorities, so as to obtain the target correction task tree.

[0108] The target correction task tree segmentation module 50 is used to segment the target correction task tree into Q container-level task sets of Q task execution containers based on container performance.

[0109] The scheduling chain output module 60 is used to perform time-series scheduling analysis on 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 an elastic round-robin container scheduling chain.

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

[0111] Furthermore, the system is also used to implement the following functions:

[0112] A preset task type weight set is established; based on the task type, multiple basic task weights of the multiple original reconciliation tasks are retrieved from the task type weight set; multiple task level positions of the multiple original reconciliation tasks are extracted from the H hierarchical task trees; based on the multiple basic task weights and multiple task level positions, the multiple basic priorities of the multiple original reconciliation tasks are set.

[0113] Furthermore, the system is also used to implement the following functions:

[0114] Based on the Q container performance data reported by the Q task execution containers, initialize Q container performance matrices; extract the average number of parallel tasks from the Q container performance data, and calculate the subtree segmentation scale based on the task tree level depth and the average number of parallel tasks; using the subtree segmentation scale, segment the target modified task tree from the root node to obtain multiple segmented subtrees; traverse the multiple segmented subtrees using the Q container performance matrices to perform cross-container load balancing of tasks, and obtain the Q container-level task sets.

[0115] Furthermore, the system is also used to implement the following functions:

[0116] The first container performance matrix is ​​used to traverse the first segmentation subtree to match task type and task parallelism requirements. If both the task type and task parallelism requirements are set to 1, the first container fit is output based on task processing latency quantization. This process is repeated until Q container fits are obtained. These Q container fits are then sorted in ascending order to extract the top O task execution containers from the Q task execution containers, forming the first group of candidate containers. This process is repeated again, using the Q container performance matrices to traverse the multiple segmentation subtrees to perform cross-container task allocation, resulting in multiple groups of candidate containers. Load balancing allocation is then performed on these multiple groups of candidate containers to obtain multiple target task containers. Based on these multiple target task containers, the multiple segmentation subtrees are aggregated to obtain the Q container-level task sets.

[0117] Furthermore, the system is also used to implement the following functions:

[0118] The container performance data includes a task type adaptation list, a task processing latency list, and the maximum number of parallel tasks.

[0119] Furthermore, the system is also used to implement the following functions:

[0120] Extract the first timeliness indicator set for the first original reconciliation task, and output the first timeliness score based on the first timeliness indicator set; classify the amount weight according to the task amount range of the first original reconciliation task, and set the first amount weight; call the first task execution success rate locally according to the task type of the first original reconciliation task; and output the first dynamic priority by linearly weighting the first timeliness score, the first amount weight, and the first task execution success rate into the dynamic priority evaluation model.

[0121] Furthermore, the system is also used to implement the following functions:

[0122] A preset priority difference scale is established; based on the P basic priorities and P dynamic priorities of P task nodes in the first hierarchical task tree, P priority difference rates are calculated and output; depending on whether the P priority difference rates satisfy 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 of priority to obtain a sequence of nodes to be corrected; based on the sequence of nodes to be corrected, priority balancing of sibling nodes and priority inheritance of parent nodes are performed on each of the T nodes to be corrected along the first hierarchical task tree to obtain a first hierarchical correction tree; in this way, the hierarchical correction of the H hierarchical task trees is performed based on the priority differences of the multiple basic priorities and multiple dynamic priorities, and H hierarchical correction trees are output; the target correction task tree is constructed by connecting the H hierarchical correction trees through virtual dependencies.

[0123] Furthermore, the system is also used to implement the following functions:

[0124] H root nodes and H leaf nodes are selected from the H hierarchical correction trees; H virtual dependency features of the H hierarchical correction trees are constructed according to the dynamic priority of the H root nodes and H leaf nodes; based on the H virtual dependency features, the H hierarchical correction trees are connected to complete the construction of the target correction task tree.

[0125] Furthermore, the system is also used to implement the following functions:

[0126] Based on the Q task processing latency list of the Q task execution containers, the task processing latency of the Q container-level task sets is predicted, and the Q task processing latency sets are output. Based on the Q task processing latency sets and the execution progress of the Q container-level task sets in the target correction task tree, the timing scheduling interval of the Q task execution containers is calculated, and the elastic round-robin container scheduling chain is output.

[0127] It should be noted that the order of the embodiments described above is merely for descriptive purposes and does not represent the superiority or inferiority of the embodiments. Furthermore, the above description focuses on specific embodiments of this specification. Additionally, the processes depicted in the accompanying drawings do not necessarily require a specific or sequential order to achieve the desired results. In some implementations, multitasking and parallel processing are possible or may be advantageous.

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

[0129] This specification and accompanying drawings are merely illustrative examples of this application and are intended to cover any and all modifications, variations, combinations, or equivalents within the scope of this application. Clearly, those skilled in the art can make various alterations and modifications to this application without departing from its scope. Therefore, if such modifications and modifications fall within the scope of this application and its equivalents, this application intends to include such modifications and modifications.

Claims

1. A dynamic priority based reconciliation task scheduling management method, characterized in that, The method comprises: aggregating a plurality of original reconciliation tasks according to a task dependency topology to obtain H hierarchical task trees, wherein each hierarchical task tree is composed of a plurality of task nodes and directed edges connecting the nodes, the hierarchical relationship of the nodes reflects the execution sequence of the tasks, and the tasks at a lower level are the preceding tasks of the tasks at a higher level; backtracking to set a plurality of basic priorities of the plurality of original reconciliation tasks from the H hierarchical task trees; evaluating the task priorities based on the task attributes of the plurality of original reconciliation tasks to output a plurality of dynamic priorities; performing hierarchical correction and connection of the H hierarchical task trees according to the priority difference between the plurality of basic priorities and the plurality of dynamic priorities to obtain a target corrected task tree; dividing the target corrected task tree into Q container-level task sets of Q task execution containers according to container efficiency; performing timing scheduling analysis of the Q task execution containers according to the execution progress of the Q container-level task sets in the target corrected task tree to output an elastic rotation container scheduling chain; based on the elastic rotation container scheduling chain, scheduling the Q task execution containers to perform dynamic scheduling reconciliation of the Q container-level task sets along the target corrected task tree in descending order of priority; the method comprises: initializing Q container efficiency matrices according to Q container efficiency data reported by the Q task execution containers; extracting the average number of parallel tasks from the Q container efficiency data, and calculating a sub-tree division scale according to the hierarchical depth of the task tree and the average number of parallel tasks; using the sub-tree division scale to divide the target corrected task tree from the root node to obtain a plurality of divided sub-trees; using the Q container efficiency matrices to traverse the plurality of divided sub-trees to perform task cross-container load balancing distribution to obtain the Q container-level task sets, the method comprising: using a first container efficiency matrix to traverse a first divided sub-tree to perform task type and task parallel demand matching; if the task type adaptation result is 1 and the task parallel demand adaptation result is 1, then output the first container adaptation degree based on task processing delay quantization; in this way, after obtaining Q container adaptation degrees, the Q container adaptation degrees are arranged in ascending order to extract the first O task execution containers from the Q task execution containers to form a first group of candidate containers; in this way, using the Q container efficiency matrices to traverse the plurality of divided sub-trees to perform task cross-container distribution to obtain a plurality of groups of candidate containers; performing load balancing distribution screening on the plurality of groups of candidate containers to obtain a plurality of target task containers; aggregating the plurality of divided sub-trees according to the plurality of target task containers to obtain the Q container-level task sets; the container efficiency data comprises a task type adaptation list, a task processing delay list, and a maximum task parallel number; the method comprises: According to the Q task processing time delay list of the Q task execution containers, the Q container level task set is processed for task processing time delay prediction, and Q task processing time delay sets are output; According to the Q task processing time delay set and the execution progress of the Q container level task set in the target correction task tree, the timing scheduling interval of the Q task execution containers is calculated, and the elastic rotation container scheduling chain is output.

2. The dynamic priority based reconciliation task scheduling management method of claim 1, wherein, The method comprises: presetting a task type weight set; 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; extracting a plurality of task level positions of the plurality of original reconciliation tasks from the H hierarchical task trees; According to the plurality of basic task weights and the plurality of task level positions, the plurality of basic priorities of the plurality of original reconciliation tasks are set.

3. The dynamic priority based reconciliation task scheduling management method of claim 1, wherein, Based on the task attributes of the plurality of original reconciliation tasks, the task priority is evaluated, and a plurality of dynamic priorities are output, the method comprising: extracting a first timeliness index set of a first original reconciliation task, and quantitatively outputting a first timeliness score according to the first timeliness index set; According to the task amount interval where the first original reconciliation task is located, the amount weight is classified, and the first amount weight is set; According to the task type of the first original reconciliation task, the first task execution success rate is locally called; By inputting the first timeliness score, the first amount weight and the first task execution success rate into the dynamic priority evaluation model for linear weighting, the first dynamic priority is output.

4. The dynamic priority based reconciliation task scheduling management method of claim 1, wherein, According to the priority difference between the plurality of basic priorities and the plurality of dynamic priorities, the hierarchical correction connection of the H hierarchical task trees is carried out, and a target correction task tree is obtained, the method comprising: presetting a priority difference scale; According to the P basic priorities and the P dynamic priorities of the P task nodes in the first hierarchical task tree, P priority difference rates are calculated and output; According to whether the P priority difference rates meet the priority difference scale, T to-be-corrected nodes are located in the first hierarchical task tree; Based on the priority ascending order, the T to-be-corrected nodes are arranged to obtain a to-be-corrected node sequence; According to the to-be-corrected node sequence, the T to-be-corrected nodes are processed one by one along the first hierarchical task tree for sibling node priority balancing and parent node priority inheritance processing to obtain a first hierarchical correction tree. In this way, according to the priority difference between the plurality of basic priorities and the plurality of dynamic priorities, the hierarchical correction of the H hierarchical task trees is carried out, and H hierarchical correction trees are output. The H hierarchical correction trees are connected by constructing virtual dependencies to complete the construction of the target correction task tree.

5. The dynamic priority based reconciliation task scheduling management method of claim 4, wherein, The H hierarchical correction trees are connected by constructing virtual dependencies to complete the construction of the target correction task tree, the method comprising: From the H hierarchical correction trees, H root nodes and H groups of leaf nodes are selected; According to the dynamic priorities of the H root nodes and the H groups of leaf nodes, H virtual dependency features of the H hierarchical correction trees are constructed. According to the H virtual dependency features, the H hierarchical revision trees are concatenated, and construction of the target revision task tree is completed.

6. A dynamic priority based reconciliation task scheduling management system, 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-5, and the system comprises: a hierarchical task tree acquisition module configured to aggregate a plurality of original reconciliation tasks according to a task dependency topology to obtain H hierarchical task trees; a priority setting module configured to inversely 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 task attributes of the plurality of original reconciliation tasks and output a plurality of dynamic priorities; a target revision task tree acquisition module configured to perform hierarchical revision concatenation of the H hierarchical task trees according to priority differences between the plurality of basic priorities and the plurality of dynamic priorities to obtain a target revision task tree; a target revision task tree segmentation module configured to segment the target revision task tree into Q container-level task sets of Q task execution containers according to container efficiency; a scheduling chain output module configured to perform timing scheduling analysis of the Q task execution containers according to execution progress of the Q container-level task sets in the target revision task tree and output an elastic rotation container scheduling chain; a dynamic scheduling reconciliation module configured to schedule the Q task execution containers to perform dynamic scheduling reconciliation of the Q container-level task sets along the target revision task tree in a priority descending order based on the elastic rotation container scheduling chain.

Images