Group insurance policy data processing method and device, equipment and medium

Abstract

The invention belongs to the technical field of data processing, is suitable for financial scenes and medical scenes, and discloses a group insurance policy data processing method and device, equipment and a medium, and the method comprises the steps: obtaining to-be-processed group insurance policy data, and carrying out the multi-thread task decomposition, generating a plurality of to-be-processed sub-tasks corresponding to the to-be-processed group insurance policy data; based on a consistent Hash algorithm, distributing each to-be-processed sub-task to each computing node of a distributed cluster; the resource utilization rate of each computing node is monitored in real time based on a resource monitor, and the monitored resource utilization rate is synchronized to a load balancer; the load balancer evaluates the load condition of each computing node according to the response delay and the error rate, and dynamically adjusts the flow distribution of each computing node according to the evaluation result; and asynchronous processing is carried out on the sub-tasks in each computing node after the flow distribution is adjusted, and the asynchronously processed group insurance policy data is generated, so that the processing efficiency of the group insurance policy data is effectively improved.

Description

Technical Field

[0001] The present invention belongs to the field of data processing technology and is applicable to financial and medical scenarios. In particular, it relates to a method, device, equipment and medium for processing group insurance policy data. Background Art

[0002] In the group insurance sector, traditional policy processing methods rely primarily on serial processing mechanisms to handle massive amounts of policy data. This results in excessively long overall system response times, making it difficult to meet the growing real-time demands of business. This efficiency declines significantly when handling complex queries or performing large-scale batch operations, significantly impairing user experience. For example, in the financial stock trading sector, relying on traditional serial processing architectures during peak trading periods can lead to transaction delays, preventing investors from making timely transactions, and impacting market efficiency and customer trust. In the healthcare insurance sector, processing large amounts of patient information is slow, resulting in inefficient patient visits and prolonged insurance claims processing times, which in turn impacts patient and policyholder satisfaction with healthcare services. Furthermore, traditional policy processing methods fail to effectively adapt to the advantages of modern computing resource architectures. Consequently, they are often limited to single-threaded or single-node operations when processing core policy data. This not only leads to significant idle computing resources but also exposes them to the risk of resource exhaustion during peak business hours. This can lead to service interruptions or unavailability, severely impacting business continuity and customer satisfaction.

[0003] In view of this, how to improve the processing efficiency of group insurance policies is a technical problem that needs to be solved urgently. Summary of the Invention

[0004] The present invention provides a method, device, equipment and medium for processing group insurance policy data to solve the technical problem of low efficiency in the existing processing of large group insurance policies.

[0005] In a first aspect, the present invention provides a method for processing group insurance policy data, comprising:

[0006] Acquire group insurance policy data to be processed, and perform multi-threaded task decomposition on the group insurance policy data to be processed to generate a plurality of subtasks to be processed corresponding to the group insurance policy data to be processed;

[0007] Based on the consistent hashing algorithm, each subtask to be processed is assigned to each computing node in the distributed cluster, where each subtask to be processed is assigned to one computing node;

[0008] Monitor the resource utilization of each computing node in real time based on the resource monitor, and synchronize the monitored resource utilization to the load balancer;

[0009] The load balancer evaluates the load status of each computing node based on the response delay and error rate, and dynamically adjusts the traffic distribution of each computing node based on the evaluation results;

[0010] The subtasks in each computing node after the traffic distribution is adjusted are processed asynchronously to generate asynchronously processed group policy data.

[0011] In a second aspect, the present invention provides a device for processing group insurance policy data, comprising:

[0012] An acquisition module, configured to acquire group insurance policy data to be processed, and perform multi-threaded task decomposition on the group insurance policy data to be processed, thereby generating a plurality of subtasks to be processed corresponding to the group insurance policy data to be processed;

[0013] An allocation module, configured to allocate each pending subtask to each computing node of the distributed cluster based on a consistent hashing algorithm, wherein each pending subtask is allocated to one computing node;

[0014] The monitoring module is used to monitor the resource utilization of each computing node in real time based on the resource monitor and synchronize the monitored resource utilization to the load balancer;

[0015] An adjustment module, wherein the load balancer evaluates the load status of each computing node based on the response delay and error rate, and dynamically adjusts the traffic distribution of each computing node based on the evaluation results;

[0016] The processing module is used to asynchronously process the subtasks in each computing node after the traffic distribution is adjusted, and generate the asynchronously processed group insurance policy data.

[0017] In a third aspect, the present invention provides a computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the steps of the above-mentioned method for processing group insurance policy data when executing the computer program.

[0018] In a fourth aspect, the present invention provides a computer-readable storage medium storing a computer program, which implements the steps of the above-mentioned method for processing group insurance policy data when executed by a processor.

[0019] The aforementioned group policy data processing method, apparatus, device, and medium implement a solution that, through multi-threaded task decomposition of the group policy data to be processed, can divide large-scale data tasks into multiple smaller subtasks, enabling these subtasks to be processed in parallel across multiple computing nodes. Using a consistent hashing algorithm, load-balanced distribution of the subtasks to be processed across the computing nodes of a distributed cluster allows for the rational allocation of computing resources, maximizing resource utilization and effectively improving the efficiency of group policy data processing. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following briefly introduces the drawings required for use in the description of the embodiments of the present invention. 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 paying any creative labor.

[0021] Figure 1 This is a schematic diagram of an application environment of a method for processing group insurance policy data in one embodiment of the present invention;

[0022] Figure 2 This is a flow chart of a method for processing group insurance policy data in one embodiment of the present invention;

[0023] Figure 3 yes Figure 2 A schematic flow chart of a specific implementation of step S20;

[0024] Figure 4 yes Figure 2 A schematic flow chart of a specific implementation of step S30;

[0025] Figure 5 yes Figure 2 A schematic flow chart of a specific implementation of step S40;

[0026] Figure 6 yes Figure 2 A schematic flow chart of a specific implementation of step S50;

[0027] Figure 7 It is a structural diagram of a device for processing group insurance policy data in one embodiment of the present invention;

[0028] Figure 8 is a structural diagram of a computer device in one embodiment of the present invention;

[0029] Figure 9 FIG. 2 is another structural diagram of a computer device according to an embodiment of the present invention. DETAILED DESCRIPTION

[0030] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of them. All other embodiments obtained by ordinary technicians in this field based on the embodiments of the present invention without making any creative efforts shall fall within the scope of protection of the present invention.

[0031] The method for processing group insurance policy data provided by the embodiment of the present invention can be applied in the following situations: Figure 1 In the application environment, Figure 1 This is a schematic diagram of an application environment for a method for processing group insurance policy data in an embodiment of the present invention; wherein, the client communicates with the server through a network. The server can obtain the group insurance policy data to be processed through the client, and perform multi-threaded task decomposition on the group insurance policy data to be processed, generating multiple sub-tasks to be processed corresponding to the group insurance policy data to be processed; based on the consistent hashing algorithm, each sub-task to be processed is assigned to each computing node of the distributed cluster, wherein each sub-task to be processed is assigned to one computing node; based on the resource monitor, the resource utilization of each computing node is monitored in real time, and the monitored resource utilization is synchronized to the load balancer; the load balancer evaluates the load status of each computing node based on the response delay and error rate, and dynamically adjusts the traffic distribution of each computing node based on the evaluation result; asynchronously processes the sub-tasks in each computing node after the traffic distribution is adjusted, and generates asynchronously processed group insurance policy data. In the present invention, when processing group insurance policy data, by performing multi-threaded task decomposition on the group insurance policy data to be processed, large-scale data tasks can be cut into multiple smaller sub-tasks, so that these sub-tasks can be processed in parallel on multiple computing nodes. In addition, by load-balancing the subtasks to be processed to the computing nodes of the distributed cluster based on the consistent hashing algorithm, computing resources can be reasonably allocated, resource utilization can be maximized, and the processing efficiency of group insurance policy data can be effectively improved. The present invention will be described in detail below through specific embodiments.

[0032] See also Figure 2 As shown, Figure 2 A flowchart of a method for processing group insurance policy data provided by an embodiment of the present invention is provided. The method for processing group insurance policy data specifically includes the following steps:

[0033] S10: Obtain the group policy data to be processed, and perform multi-threaded task decomposition on the group policy data to be processed, and generate a plurality of sub-tasks to be processed corresponding to the group policy data to be processed. Specifically, in an embodiment of the present invention, by decomposing a large-scale data task into multiple sub-tasks through multi-threading, parallel processing can be achieved, which greatly shortens the overall processing time. For example, in financial insurance claims, especially in catastrophic events or peak periods, a large number of claims applications need to be processed quickly. By decomposing tasks through multi-threading, multiple claims applications can be processed in parallel. In the medical health insurance scenario, policy data involves a large amount of customer health information, physical examination reports, claims applications, etc. By decomposing these data into multiple sub-tasks for multi-threaded processing, delays can be reduced when processing health insurance claims, ensuring that a large number of claims applications can be completed quickly, and improving the customer's claims efficiency and experience.

[0034] S20: Based on the consistent hashing algorithm, each subtask to be processed is assigned to each computing node of the distributed cluster, wherein each subtask to be processed is assigned to a computing node. Specifically, in the embodiment of the present invention, the consistent hashing algorithm ensures that tasks are evenly distributed to each computing node to avoid some nodes being overloaded while other nodes are idle. This not only improves resource utilization, but also avoids performance bottlenecks caused by overloading of a certain node. For example, in financial insurance claims, claims data from different regions can be assigned to different computing nodes to avoid overloading of a single node and improve the efficiency of claims data processing. In the field of health insurance, consistent hashing is used to evenly distribute tasks to different computing nodes to ensure that data such as claims cases and physical examination reports can be quickly and efficiently distributed and processed, avoiding delays caused by overloading of certain nodes, and improving the overall efficiency of claims and health audits. Specifically, as Figure 3 As stated, Figure 3 This is a flow chart of a specific implementation of step S20, which specifically includes the following steps S21-S22:

[0035] S21: Calculate the first hash value corresponding to each computing node of the distributed cluster, and build a consistent hash ring based on the first hash value. Specifically, in an embodiment of the present invention, by calculating the hash value of the node and building a hash ring, the node can automatically adjust the distribution of tasks when the load is uneven or the system is expanded, so as to avoid resource conflicts between nodes. For example, in the claim review of medical health insurance, a large number of patients' claims applications and health reports need to be processed in real time. By building a consistent hash ring, each task can be evenly distributed to the computing nodes, and new computing nodes can be seamlessly added to process more health data or claims cases without the need for a large number of reallocations of existing tasks.

[0036] S22: Calculate the second hash value corresponding to each subtask to be processed, search for a computing node that matches each subtask to be processed in the consistent hash ring based on the second hash value, and assign each subtask to be processed to the found computing node according to the matching result. Specifically, in an embodiment of the present invention, by calculating the hash value of each subtask to be processed and searching for a computing node that matches its hash value in the consistent hash ring, the accuracy of task assignment can be ensured. For example, in the claims processing of medical health insurance, it is necessary to reasonably assign computing nodes according to different claims cases, physical examination reports or health data. By assigning each subtask to be processed to the found computing node, it can be ensured that each claim case is assigned to a suitable computing node for processing, which effectively improves the processing efficiency and ensures that even if a node failure or expansion occurs, the tasks can still be quickly and efficiently reallocated, thereby ensuring the stability and high availability of the system.

[0037] S30: Based on the resource monitor, the resource utilization of each computing node is monitored in real time, and the monitored resource utilization is synchronized to the load balancer. Specifically, in the embodiment of the present invention, by monitoring the resource usage of each computing node in real time, the load balancer can make timely adjustments to avoid excessive resource consumption or idleness of certain nodes, and ensure that tasks can be efficiently distributed in the cluster. Specifically, Figure 4 As stated, Figure 4 This is a flow chart of a specific implementation of step S30, which specifically includes the following steps S31-S32:

[0038] S31: Deploy a resource indicator collector on each computing node and use the resource indicator collector to collect resource utilization data for each computing node in real time. The resource utilization data includes at least CPU utilization, memory usage, and network IO rate. Specifically, in embodiments of the present invention, real-time collection of key indicators such as CPU, memory, and network IO enables a comprehensive understanding of the current operating status of the computing node, helping the load balancer to promptly understand the load status of each node. Through real-time resource monitoring, early warnings or throttling can be issued before resource usage approaches a bottleneck, thereby preventing service interruptions or performance degradation caused by resource exhaustion. For example, during peak periods of financial and insurance claims, such as natural disasters, epidemics, or concentrated insurance claims processing cycles, the number of processing requests increases dramatically. After deploying the resource indicator collector, bottlenecks in node resources in the claims processing system can be promptly identified and adjustments can be made in a timely manner to avoid system paralysis and ensure that customer claims requests can be continuously responded to. In medical and health insurance, the processing of massive amounts of data, such as claims data, medical records, and health records, involves the simultaneous uploading of multiple medical institutions or physical examination reports, which can cause a sudden increase in node pressure. By deploying resource collectors, we can dynamically control the operating status of each node that processes these medical data, quickly respond to sudden traffic, and ensure the stable operation of the health insurance system.

[0039] S32: Convert the resource utilization data into standardized metrics recognizable by the load balancer, and push the standardized metrics to the load balancer in real time via the message queue middleware. Specifically, in this embodiment of the present invention, after the resource metrics are standardized, they can be directly parsed and used by the load balancer, enabling node load determination based on unified standards, thereby enhancing the intelligence of automatic traffic diversion and load adjustment.

[0040] S40: The load balancer evaluates the load status of each computing node based on the response delay and error rate, and dynamically adjusts the traffic distribution of each computing node based on the evaluation results. Specifically, in the embodiment of the present invention, the load balancer dynamically adjusts the traffic distribution based on the response delay and error rate of the node to ensure uniform system load, avoid delays or errors in certain nodes due to excessive load, and improve the overall response capability of the system. Specifically, Figure 5 As stated, Figure 5 This is a flow chart of a specific implementation of step S40, which specifically includes the following steps S41-S42:

[0041] S41: Calculate the load evaluation value of each computing node based on the preset weights of the response delay and error rate of each computing node load. Specifically, in an embodiment of the present invention, by comprehensively considering the two key performance indicators of response delay and error rate, and calculating the load evaluation value according to their weights, the load situation of the computing node can be accurately reflected. This multi-dimensional evaluation method can avoid the misleading possibility of judging only by a single indicator, thereby ensuring more accurate resource allocation. For example, in the process of medical and health insurance claims, a large amount of complex data is involved, such as patient health records, medical images, etc. The processing of these data often consumes more computing resources. Comprehensively evaluating the response delay and error rate can timely discover the bottlenecks of some nodes in processing data, avoid the accuracy of medical data analysis affected by network delays or processing errors, and ensure a smooth and efficient claims process.

[0042] S42: When the load evaluation value of the computing node exceeds a preset first threshold, traffic requests allocated to the computing node are redirected to an adjacent computing node with the lowest load evaluation value. Specifically, in this embodiment of the present invention, this mechanism can automatically detect computing nodes with excessive load and quickly redirect requests to adjacent nodes with lower loads.

[0043] S43: When the load evaluation value of the computing node is lower than the preset second threshold, the traffic request allocated to the computing node is allocated to the corresponding computing node. Specifically, in an embodiment of the present invention, when the load of certain computing nodes is low, the traffic can be evenly distributed to these nodes to ensure full utilization of computing resources. This not only avoids certain nodes from being idle, but also speeds up the overall processing speed. For example, in medical health insurance, different nodes usually process different task types and processing priorities. During non-peak hours, some computing nodes may have low loads. At this time, by allocating more traffic to these nodes, the overall processing capacity can be improved, the processing time can be shortened, and the efficiency of claims or health data analysis can be improved.

[0044] S50: Asynchronously process the subtasks in each computing node after adjusting the traffic distribution, and generate the asynchronously processed group policy data. Specifically, in the embodiment of the present invention, through asynchronous processing, each node does not have to wait for other nodes to complete tasks when processing subtasks, which can reduce the waiting time in the processing process and improve the throughput of the system. In financial insurance claims, especially claims cases that require complex calculations or data audits, asynchronous processing can speed up the speed of claims review and reduce delays caused by waiting for a task to be completed. For example, when processing multiple claims cases, each case can be reviewed independently, and the processing of other cases will not be affected by the long processing time of one case. In medical and health insurance claims, the customer's physical examination report, medical records, medical expense documents, etc. need to be processed asynchronously. Asynchronous processing can avoid waiting for a single node to complete all tasks, and ensure that each independently reviewed task can be processed independently and in parallel, thereby reducing the overall time of claims review and improving customer experience. Specifically, such as Figure 6 As stated, Figure 6 This is a flow chart of a specific implementation of step S50, which specifically includes the following steps S51-S52:

[0045] S51: The asynchronously processed group policy data is input into the Bayesian model for training to generate a policy risk assessment model. Specifically, in an embodiment of the present invention, the policy risk assessment model generated by Bayesian model training can accurately assess the risk of group policies based on a large amount of historical data and statistical information. This probability-based model can combine multiple factors to predict future risks and more accurately identify potential high-risk groups. For example, in medical health insurance, especially group medical insurance, a large amount of complex health data is involved. By using the Bayesian model, it is possible to accurately assess the risk level of group policies by combining multi-dimensional data such as personal health status, medical history, and disease type, helping insurance companies to formulate appropriate premium strategies based on the health risks of different groups, optimize claims management, and ensure the interests of both insurance companies and policyholders.

[0046] S52: Identify the associated risks of the group policy based on the generated policy risk assessment model, and dynamically adjust the premium factors based on the identified associated risks. Specifically, in an embodiment of the present invention, the premium factors can be dynamically adjusted based on the associated risks identified by the policy risk assessment model. For example, in the field of medical and health insurance, especially group medical insurance, insurance companies face differences in health risks among members of different groups. By dynamically adjusting the premium factors based on the associated risks identified by the policy risk assessment model, it can be ensured that high-risk groups bear higher premiums, while low-risk groups can enjoy lower premiums, thereby improving the fairness and sustainability of the entire insurance system. At the same time, in situations such as epidemics or large-scale health crises, insurance companies can respond flexibly and improve the effectiveness of risk management.

[0047] In one embodiment of the present invention, the method for identifying associated risks within a group policy based on a generated policy risk assessment model and dynamically adjusting premium factors based on the identified associated risks includes: obtaining historical claims data for the insured groups within the group policy; inputting the obtained historical claims data and asynchronously processed group policy data into the policy risk assessment model; and outputting a risk rating score for each insured group within the group policy; and dynamically generating a corresponding premium adjustment factor based on the mapping between the risk rating score of each insured group within the group policy and a preset benchmark premium. Incorporating historical claims data into the risk assessment model can significantly improve the timeliness and accuracy of risk identification. In healthcare insurance, historical claims data is particularly important, reflecting the insured population's health status and claims history. For example, a group may have frequently filed claims for a particular illness in the past, indicating poor health and the likelihood of continued high medical expenses. Through this risk assessment, insurance companies can provide more targeted health management or additional protection for these high-risk groups, reducing future claims pressure.

[0048] As can be seen, in the above solution, when processing group insurance policies, multi-threaded task decomposition of the group insurance policy data can be used to divide the large-scale data task into multiple smaller subtasks, allowing these subtasks to be processed in parallel across multiple computing nodes. Using a consistent hashing algorithm, load-balanced distribution of the subtasks to be processed across the computing nodes of the distributed cluster ensures the optimal allocation of computing resources, maximizes resource utilization, and effectively improves the efficiency of group insurance policy data processing.

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

[0050] In one embodiment, a device for processing group insurance policy data is provided, which corresponds to the method for processing group insurance policy data in the above embodiment. Figure 7 As shown, Figure 7 7 is a schematic diagram of a structure of a device for processing group policy data according to an embodiment of the present invention. The device for processing group policy data includes an acquisition module 71, an allocation module 72, a monitoring module 73, an adjustment module 74, and a processing module 75. Detailed descriptions of each functional module are as follows:

[0051] An acquisition module 71 is configured to acquire group insurance policy data to be processed, and perform multi-threaded task decomposition on the group insurance policy data to be processed, thereby generating a plurality of subtasks to be processed corresponding to the group insurance policy data to be processed;

[0052] an allocation module 72 for allocating each subtask to be processed to each computing node of the distributed cluster based on a consistent hashing algorithm, wherein each subtask to be processed is allocated to one computing node;

[0053] Monitoring module 73, for monitoring the resource utilization of each computing node in real time based on the resource monitor, and synchronizing the monitored resource utilization to the load balancer;

[0054] Adjustment module 74, the load balancer evaluates the load status of each computing node based on the response delay and error rate, and dynamically adjusts the traffic distribution of each computing node based on the evaluation results;

[0055] The processing module 75 is used to asynchronously process the subtasks in each computing node after the traffic distribution is adjusted, and generate asynchronously processed group insurance policy data.

[0056] In one embodiment, the allocation module 72 is specifically configured to:

[0057] Calculate a first hash value corresponding to each computing node of the distributed cluster, and build a consistent hash ring based on the first hash value;

[0058] Calculate the second hash value corresponding to each subtask to be processed, search for a computing node matching each subtask to be processed in the consistent hash ring based on the second hash value, and assign each subtask to be processed to the found computing node according to the matching result.

[0059] In one embodiment, the allocation module 72 is further configured to:

[0060] Deploy a resource indicator collector on each computing node and use the resource indicator collector to collect resource utilization data of each computing node in real time. The resource utilization data includes at least CPU utilization, memory usage, and network IO rate.

[0061] The resource utilization data is converted into standardized indicators that can be recognized by the load balancer, and the standardized indicators are pushed to the load balancer in real time through the message queue middleware.

[0062] In one embodiment, the monitoring module 73 is specifically configured to:

[0063] Calculate the load evaluation value of each computing node based on the preset weights of the response delay and error rate of each computing node load;

[0064] When the load evaluation value of the computing node exceeds a preset first threshold, redirecting the traffic request assigned to the computing node to an adjacent computing node with the lowest load evaluation value;

[0065] When the load evaluation value of the computing node is lower than a preset second threshold, the traffic request allocated to the computing node is allocated to the corresponding computing node.

[0066] In one embodiment, the adjustment module 74 is specifically configured to:

[0067] Based on the resource utilization of the computing nodes, the asynchronous execution engine is triggered to process the subtasks in the message queue in parallel;

[0068] Capture the abnormal status of subtasks in the message queue in real time and record the abnormal status information to the error isolation pool;

[0069] The asynchronous processing results of each computing node are integrated through the data integration engine to generate the asynchronous processing results of the group insurance policy data.

[0070] In one embodiment, the processing module 75 is specifically configured to:

[0071] Inputting the asynchronously processed group policy data into a Bayesian model for training to generate a policy risk assessment model;

[0072] Based on the generated policy risk assessment model, the associated risks of group policies are identified, and the premium factors are dynamically adjusted based on the identified associated risks.

[0073] In one embodiment, the processing module 75 is further configured to:

[0074] Obtaining historical claims data for the insured groups in the group policy, inputting the acquired historical claims data and the asynchronously processed group policy data into the policy risk assessment model, and outputting a risk level score for each insured group in the group policy;

[0075] Based on the mapping relationship between the risk level score of each insured group in the group insurance policy and the preset benchmark premium, the corresponding premium adjustment coefficient is dynamically generated.

[0076] The present invention provides a device for processing group insurance policy data. When processing group insurance policies, this device performs multi-threaded task decomposition on the group policy data to be processed, splitting large-scale data tasks into multiple smaller subtasks, enabling these subtasks to be processed in parallel across multiple computing nodes. By using a consistent hashing algorithm to load-balance the subtasks across the computing nodes of a distributed cluster, computing resources can be rationally allocated, maximizing resource utilization and effectively improving the efficiency of group insurance policy data processing.

[0077] The specific definitions of the group policy data processing device can be found in the definitions of the group policy data processing method described above and will not be repeated here. Each module in the group policy data processing device described above can be implemented in whole or in part via software, hardware, or a combination thereof. Each of these modules can be embedded in or independent of a processor in a computer device in hardware form, or stored in a computer device memory in software form, allowing the processor to call and execute the corresponding operations of each module.

[0078] In one embodiment, a computer device is provided. The computer device may be a server, and its internal structure diagram may be as follows: Figure 8 As shown, Figure 8 The present invention is a schematic diagram of the structure of a computer device according to an embodiment of the present invention. The computer device includes a processor, a memory, a network interface, and a database connected via a system bus. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes non-volatile and / or volatile storage media and internal memory. The non-volatile storage medium stores an operating system, a computer program, and a database. The internal memory provides an environment for the operation of the operating system and computer program in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external client via a network connection. When executed by the processor, the computer program implements the functions or steps on the server side of a method for processing group insurance policy data.

[0079] In one embodiment, a computer device is provided. The computer device may be a client, and its internal structure diagram may be as follows: Figure 9 As shown, Figure 9This is another schematic diagram of the structure of a computer device according to one embodiment of the present invention. The computer device includes a processor, memory, a network interface, a display screen, and an input device connected via a system bus. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of the operating system and computer program in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external server via a network connection. When executed by the processor, the computer program implements the client-side functions or steps of a method for processing group insurance policy data.

[0080] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the following steps are performed:

[0081] Acquire group insurance policy data to be processed, and perform multi-threaded task decomposition on the group insurance policy data to be processed to generate a plurality of subtasks to be processed corresponding to the group insurance policy data to be processed;

[0082] Based on the consistent hashing algorithm, each subtask to be processed is assigned to each computing node in the distributed cluster, where each subtask to be processed is assigned to one computing node;

[0083] Monitor the resource utilization of each computing node in real time based on the resource monitor, and synchronize the monitored resource utilization to the load balancer;

[0084] The load balancer evaluates the load status of each computing node based on the response delay and error rate, and dynamically adjusts the traffic distribution of each computing node based on the evaluation results;

[0085] The subtasks in each computing node after the traffic distribution is adjusted are processed asynchronously to generate asynchronously processed group policy data.

[0086] In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored. When the computer program is executed by a processor, the following steps are implemented:

[0087] Acquire group insurance policy data to be processed, and perform multi-threaded task decomposition on the group insurance policy data to be processed to generate a plurality of subtasks to be processed corresponding to the group insurance policy data to be processed;

[0088] Based on the consistent hashing algorithm, each subtask to be processed is assigned to each computing node in the distributed cluster, where each subtask to be processed is assigned to one computing node;

[0089] Monitor the resource utilization of each computing node in real time based on the resource monitor, and synchronize the monitored resource utilization to the load balancer;

[0090] The load balancer evaluates the load status of each computing node based on the response delay and error rate, and dynamically adjusts the traffic distribution of each computing node based on the evaluation results;

[0091] The subtasks in each computing node after the traffic distribution is adjusted are processed asynchronously to generate asynchronously processed group policy data.

[0092] It should be noted that the above functions or steps that can be implemented by the computer-readable storage medium or computer device can be found in the relevant descriptions of the server side and the client side in the aforementioned method embodiment. To avoid repetition, they will not be described one by one here.

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

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

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

Claims

1. A method for processing group insurance policy data, characterized in that: include: Acquire group insurance policy data to be processed, and perform multi-threaded task decomposition on the group insurance policy data to be processed to generate a plurality of subtasks to be processed corresponding to the group insurance policy data to be processed; Based on the consistent hashing algorithm, each subtask to be processed is assigned to each computing node in the distributed cluster, where each subtask to be processed is assigned to one computing node; Monitor the resource utilization of each computing node in real time based on the resource monitor, and synchronize the monitored resource utilization to the load balancer; The load balancer evaluates the load status of each computing node based on the response delay and error rate, and dynamically adjusts the traffic distribution of each computing node based on the evaluation results; The subtasks in each computing node after the traffic distribution is adjusted are processed asynchronously to generate asynchronously processed group policy data.

2. The method for processing group insurance policy data according to claim 1, characterized in that: The method of allocating each subtask to be processed to each computing node of the distributed cluster based on the consistent hashing algorithm, wherein each subtask to be processed is allocated to one computing node, includes: Calculate a first hash value corresponding to each computing node of the distributed cluster, and build a consistent hash ring based on the first hash value; Calculate the second hash value corresponding to each subtask to be processed, search for a computing node matching each subtask to be processed in the consistent hash ring based on the second hash value, and assign each subtask to be processed to the found computing node according to the matching result.

3. The method for processing group insurance policy data according to claim 1, characterized in that: The resource monitor monitors the resource utilization of each computing node in real time and synchronizes the monitored resource utilization to the load balancer, including: Deploy a resource indicator collector on each computing node and use the resource indicator collector to collect resource utilization data of each computing node in real time. The resource utilization data includes at least CPU utilization, memory usage, and network IO rate. The resource utilization data is converted into standardized indicators that can be recognized by the load balancer, and the standardized indicators are pushed to the load balancer in real time through the message queue middleware.

4. The method for processing group insurance policy data according to claim 1, characterized in that: The load balancer evaluates the load status of each computing node based on the response delay and error rate, and dynamically adjusts the traffic distribution of each computing node based on the evaluation results, including: Calculate the load evaluation value of each computing node based on the preset weights of the response delay and error rate of each computing node load; When the load evaluation value of the computing node exceeds a preset first threshold, redirecting the traffic request assigned to the computing node to an adjacent computing node with the lowest load evaluation value; When the load evaluation value of the computing node is lower than a preset second threshold, the traffic request allocated to the computing node is allocated to the corresponding computing node.

5. The method for processing group insurance policy data according to claim 1, characterized in that: The asynchronous processing of the subtasks in each computing node after the traffic distribution adjustment to generate asynchronously processed group insurance policy data includes: Based on the resource utilization of the computing nodes, the asynchronous execution engine is triggered to process the subtasks in the message queue in parallel; Capture the abnormal status of subtasks in the message queue in real time and record the abnormal status information to the error isolation pool; The asynchronous processing results of each computing node are integrated through the data integration engine to generate the asynchronous processing results of the group insurance policy data.

6. The method for processing group insurance policy data according to claim 1, characterized in that: After asynchronously processing the subtasks in each computing node after adjusting the traffic distribution to generate asynchronously processed group insurance policy data, the method further includes: Inputting the asynchronously processed group policy data into a Bayesian model for training to generate a policy risk assessment model; Based on the generated policy risk assessment model, the associated risks of group policies are identified, and the premium factors are dynamically adjusted based on the identified associated risks.

7. The method for processing group insurance policy data according to claim 1, characterized in that: The generated insurance policy risk assessment model is used to identify the associated risks of the group insurance policy, and the premium factor is dynamically adjusted based on the identified associated risks, including: Obtaining historical claims data for the insured groups in the group policy, inputting the acquired historical claims data and the asynchronously processed group policy data into the policy risk assessment model, and outputting a risk level score for each insured group in the group policy; Based on the mapping relationship between the risk level score of each insured group in the group insurance policy and the preset benchmark premium, the corresponding premium adjustment coefficient is dynamically generated.

8. A device for processing group insurance policy data, characterized in that: The device is used to implement the method for processing group insurance policy data according to any one of claims 1 to 7, and the device includes: An acquisition module, configured to acquire group insurance policy data to be processed, and perform multi-threaded task decomposition on the group insurance policy data to be processed, thereby generating a plurality of subtasks to be processed corresponding to the group insurance policy data to be processed; An allocation module, configured to allocate each pending subtask to each computing node of the distributed cluster based on a consistent hashing algorithm, wherein each pending subtask is allocated to one computing node; The monitoring module is used to monitor the resource utilization of each computing node in real time based on the resource monitor and synchronize the monitored resource utilization to the load balancer; An adjustment module, wherein the load balancer evaluates the load status of each computing node based on the response delay and error rate, and dynamically adjusts the traffic distribution of each computing node based on the evaluation results; The processing module is used to asynchronously process the subtasks in each computing node after the traffic distribution is adjusted, and generate the asynchronously processed group insurance policy data.

9. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein: When the processor executes the computer program, the steps of the method for processing group insurance policy data according to any one of claims 1 to 7 are implemented.

10. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, the steps of the method for processing group insurance policy data according to any one of claims 1 to 7 are implemented.

Images