CN113342496B

CN113342496B - Single-instance process switching method, system and storage medium

Info

Publication number: CN113342496B
Application number: CN202110706665.4A
Authority: CN
Inventors: 陈明; 宋志远; 郑旭
Original assignee: Agricultural Bank of China
Current assignee: Agricultural Bank of China
Priority date: 2021-06-24
Filing date: 2021-06-24
Publication date: 2023-11-21
Anticipated expiration: 2041-06-24
Also published as: CN113342496A

Abstract

The embodiment of the application provides a single instance process switching method, a system and a storage medium, which relate to the technical field of computers and comprise the following steps: under the condition that the process of the target service in the first service node fails, the first service node changes the state of the process of the target service in the first service node recorded in the data node, under the condition that the current control node is the second service node, the previous state of each service node read by the second service node from the data node is the updated state, the previous state read by the second service node does not comprise the working state, and under the condition that the second service node determines that the second previous state is the unique pre-preparation working state, the corresponding second previous state is changed into the working state so as to replace the process of the target service of the first service node to process the target service. Therefore, the single-instance process for processing the target service is efficiently switched from the first service node to the second service node, and the efficiency of single-instance process switching is improved.

Description

Single-instance process switching method, system and storage medium

Technical Field

The embodiment of the application relates to the technical field of computers, in particular to a single-instance process switching method, a system and a storage medium.

Background

A single instance process is a single instance process, one instance process can be used to handle a business, and a single instance process typically has exclusivity on the resources (e.g., data resources) it uses. Therefore, the single-instance process for processing the same kind of service cannot be executed concurrently, and in the case that an exception occurs in the single-instance process for processing the service, the service needs to be quickly switched to another single-instance process for processing.

Currently, in order to ensure the availability of a service system where a single instance process is located, the service system is deployed according to a single-machine cold standby mode, and when the service system fails in the deployment mode, a backup service system is manually started to process services by using the backup service system.

The manual starting of the backup service system requires changing the server address of the service system and manually starting hardware and services, and the backup service system has long starting time, resulting in longer service switching time.

Disclosure of Invention

The embodiment of the application provides a single-instance process switching method, a system and a storage medium, relates to the technical field of computers, and is beneficial to improving the efficiency of single-instance process switching.

In a first aspect, an embodiment of the present application provides a single-instance process switching method, applied to a distributed system, where the distributed system includes: a data node and M service nodes; m is a positive integer; storing M previous states in the data node; an Nth pre-state of the M pre-states is a state of a process of the target service, which is newly recorded by the data node, in the Nth service node; the states include a working state, an idle state, a death state and a pre-preparation working state; n is a positive integer less than or equal to M; the process of the target service is a single instance process; the method comprises the following steps: the first service node reads the current state of the process of the target service in the first service node to obtain a first actual state; when the first actual state represents any one of idle state, death state or pre-preparation working state of the process of the target service and the first previous state represents the process of the target service to be working state, the first service node sends a first state change instruction to the data node; the first state change instruction is used for indicating the data node to update the first previous state; the first previous state is the state of the process of the target service, which is newly recorded by the data node, in the first service node; the data node updates the first pre-state into a process representing the target service into an idle state, a pre-preparation working state or a death state according to the first actual state and the first pre-state; the second service node reads M previous states and current control nodes from the data node; when the second front state is a pre-preparation working state, the current control node is a second service node, and the front states except the second front state in the M front states are idle states or dead states, the second service node acquires heartbeat time stamps of nodes except the second service node in the M service nodes in the data nodes; the heartbeat time stamp is used for representing the latest heartbeat sending time of the service node to the data node; under the condition that each heartbeat time stamp is later than the time of reading M previous states by the second service node, the second service node sends a second state change instruction to the data node; the second state change instruction is used for changing the second previous state into the working state by the data node; the data node changes the second previous state into a working state; and under the condition that the second service node determines that the second previous state is the working state, the second service node operates the process of the target service to process the target service.

In the embodiment of the application, under the condition that the process of the target service in the first service node fails (for example, the current state of the process of the target service in the first service node is in any one of an idle state, a dead state and a pre-preparation working state), the first service node can change the state (for example, a first front state) of the process of the target service in the first service node recorded in the data node, so that under the condition that the current control node is the second service node, the first front state read by the second service node from the data node is an updated state, and the front state read by the second service node does not comprise a working state, and under the condition that the second service node determines that the second front state is the only pre-preparation working state, the corresponding second front state can be changed into the working state to replace the process of the target service of the first service node to process the target service. Therefore, the single-instance process for processing the target service is efficiently switched from the first service node to the second service node.

In a possible implementation manner, the data node updates the first previous state to represent the process of the target service as an idle state, a pre-preparation working state or a death state according to the first actual state and the first previous state, and includes: under the condition that the first actual state is used for representing the process restarting of the target service and the first previous state is used for representing the process of the target service as the working state, the data node determines that the new first previous state is used for representing the process of the target service as the pre-preparation working state.

In this way, under the condition that the process of the target service is restarted, the data node can update the stored first previous state to be the pre-preparation working state in time, so that the service node which is convenient for the subsequent access can take over the target service processed by the first service node.

In another possible implementation manner, the data node updates the first previous state to represent the process of the target service as an idle state, a pre-preparation working state or a death state according to the first actual state and the first previous state, including: under the condition that the first actual state is used for representing the process death of the target service and the first previous state is used for representing the process of the target service to be a working state, the data node determines that the new first previous state is used for representing the process of the target service to be a death state.

In this way, under the condition that the process of the target service dies (for example, the process of the target service dies or the first service node is down), the data node can timely update the stored first previous state as the dead state, so that the service node which is accessed later conveniently takes over the target service processed by the first service node.

In another possible implementation manner, the method further includes: when the second front state is a pre-preparation working state, at least one other front state is a pre-preparation working state, and the current control node is a second service node, or when the second front state is a working state, at least one other front state is a working state, and the current control node is a second service node, the second service node sends a third state change instruction to the data node; the third state change instruction is used for changing the second previous state into an idle state by the data node; wherein the other front states are front states other than the first front state and the second front state among the M front states; the data node changes the second pre-state to an idle state.

In this way, in the case where the number of pre-states of the pre-preparation operating states stored in the data node is greater than one, or the number of pre-states of the operating states is greater than one, the current control node whose pre-state is the pre-preparation operating state or the operating state may instruct the data node to update its pre-state to the idle state, avoiding that more than one pre-preparation operating state or the operating state of the pre-state is stored in the data node at the same time.

In another possible implementation manner, the method further includes: under the condition that the M previous states are idle states and the current control node is a third service node, the third service node sends a fourth state change instruction to the data node; the fourth state change instruction is used for changing the third previous state into a pre-preparation working state by the data node; the data node changes the third pre-state to the pre-ready state.

In this way, under the condition that all the previous states stored in the data node are idle states, the current control node can instruct the data node to update the corresponding previous state to the pre-prepared working state, so that the current control node can conveniently execute the target service.

In another possible implementation manner, the method further includes: any service node in M service nodes receives a target instruction; the target instruction is used for indicating any service node to update the front state of any service node in the data node; the target instruction includes a specified pre-state; any service node sends a fifth state change instruction to the data node; the fifth state change instruction is used for updating the front state of any service node in the data node by the data node; the data node updates the previous state of any service node in the data node to the designated previous state.

Thus, either service node may also receive instructions from the user or from other devices to update its corresponding previous state stored in the data node.

In another possible implementation manner, the method further includes: when any service node in the M service nodes determines that the heartbeat time stamp of the current control node in the data node and the duration of the current time are greater than a preset threshold value, any service node sends a control node update instruction to the data node; the control node updating instruction is used for updating the current control node into any service node by the data node; the data node updates the current control node recorded by the data node to any service node.

In this way, any service node can take over the current control node as a new current control node under the condition that the current control node is down or out of connection, so as to realize the control of the previous state stored in the data node.

In a second aspect, a distributed system is provided, the distributed system comprising a data node and M service nodes; m is a positive integer; storing M previous states in the data node; an Nth pre-state of the M pre-states is a state of a process of the target service, which is newly recorded by the data node, in the Nth service node; the states include a working state, an idle state, a death state and a pre-preparation working state; n is a positive integer less than or equal to M; the process of the target service is a single instance process; the first service node is used for reading the current state of the process of the target service in the first service node to obtain a first actual state; when the first actual state represents that the process of the target service is in any one of an idle state, a dead state or a pre-preparation working state and the first previous state represents that the process of the target service is in a working state, the first service node is used for sending a first state change instruction to the data node; the first state change instruction is used for indicating the data node to update the first previous state; the first previous state is the state of the process of the target service, which is newly recorded by the data node, in the first service node; the data node is used for updating the first pre-state into a process representing the target service into an idle state, a pre-preparation working state or a death state according to the first actual state and the first pre-state; the second service node is used for reading M previous states and the current control node from the data node; when the second front state is a pre-preparation working state, the current control node is a second service node, and the front states except the second front state in the M front states are idle states or dead states, the second service node is used for acquiring heartbeat time stamps of nodes except the second service node in the M service nodes in the data node; the heartbeat time stamp is used for representing the latest heartbeat sending time of the service node to the data node; the second service node is used for sending a second state change instruction to the data node under the condition that each heartbeat time stamp is later than the time of reading M previous states by the second service node; the second state change instruction is used for changing the second previous state into the working state by the data node; the data node is used for changing the second previous state into a working state; and the second service node is used for running the process of the target service to process the target service under the condition that the second pre-state is determined to be the working state.

Optionally, when the first actual state is used for representing the process restart of the target service and the first previous state is used for representing the process of the target service as the working state, the data node is used for determining that the new first previous state is used for representing the process of the target service as the pre-preparation working state.

Optionally, in the case that the first actual state is used to represent the process death of the target service, and the first previous state is used to represent the process of the target service as the working state, the data node determines that the new first previous state is used to represent the process of the target service as the death state.

Optionally, when the second previous state is the preparation working state, at least one other previous state is the preparation working state, and the current control node is the second service node, or when the second previous state is the working state, at least one other previous state is the working state, and the current control node is the second service node, the second service node is configured to send a third state change instruction to the data node; the third state change instruction is used for changing the second previous state into an idle state by the data node; wherein the other front states are front states other than the first front state and the second front state among the M front states; the data node is configured to change the second pre-state to an idle state.

Optionally, when the M previous states are idle states and the current control node is a third service node, the third service node sends a fourth state change instruction to the data node; the fourth state change instruction is used for changing the third previous state into a pre-preparation working state by the data node; the data node changes the third pre-state to the pre-ready state.

Optionally, any service node of the M service nodes is configured to receive a target instruction; the target instruction is used for indicating any service node to update the front state of any service node in the data node; the target instruction includes a specified pre-state; any service node is used for sending a fourth state change instruction to the data node; the fourth state change instruction is used for updating the front state of any service node in the data node by the data node; the data node is used for updating the previous state of any service node in the data node to the appointed previous state.

Optionally, if any service node in the M service nodes determines that the duration of the heartbeat time stamp and the current time of the current control node in the data node is greater than a preset threshold, the any service node sends a control node update instruction to the data node; the control node updating instruction is used for updating the current control node into any service node by the data node; the data node updates the current control node recorded by the data node to any service node.

In a third aspect, an embodiment of the present application provides a single instance process switching apparatus, including a processor and a memory, the memory being configured to store code instructions, the processor being configured to execute the code instructions to perform a method performed by any service node or data node of the single instance switching method described in the first aspect or any one of the possible implementations of the first aspect.

In a fourth aspect, embodiments of the present application provide a computer readable storage medium having stored therein a computer program or instructions which, when run on a computer, cause the computer to perform a method performed by any service node or data node of the first aspect or any one of the possible implementations of the first aspect.

In a fifth aspect, embodiments of the present application provide a computer program product comprising a computer program which, when run on a computer, causes the computer to perform the method performed by any one of the service nodes or data nodes of the single instance handover method described in the first aspect or any one of the possible implementations of the first aspect.

In a sixth aspect, the present application provides a chip or chip system comprising at least one processor and a communication interface, the communication interface and the at least one processor being interconnected by wires, the at least one processor being adapted to execute a computer program or instructions to perform a method performed by any service node or data node of the first aspect or any one of the possible implementations of the first aspect; the communication interface in the chip can be an input/output interface, a pin, a circuit or the like.

In one possible implementation, the chip or chip system described above further includes at least one memory, where the at least one memory has instructions stored therein. The memory may be a memory unit within the chip, such as a register, a cache, etc., or may be a memory unit of the chip (e.g., a read-only memory, a random access memory, etc.).

It should be understood that, the second aspect to the sixth aspect of the present application correspond to the technical solutions of the first aspect of the present application, and the advantages obtained by each aspect and the corresponding possible embodiments are similar, and are not repeated.

Drawings

FIG. 1 is a schematic diagram of a distributed system according to an embodiment of the present application;

fig. 2 is a schematic structural diagram of an electronic device according to an embodiment of the present application;

FIG. 3 is a flow chart illustrating a single instance process switching method according to an embodiment of the present application;

FIG. 4 is a flow chart of a single instance process state control method according to an embodiment of the present application;

FIG. 5 is a flowchart illustrating another single instance process state control method according to an embodiment of the present application;

FIG. 6 is a flowchart illustrating another method for controlling a process state according to an embodiment of the present application;

FIG. 7 is a flowchart illustrating another method for controlling a process state according to an embodiment of the present application;

FIG. 8 is a schematic diagram of a single-instance process switching device according to an embodiment of the present application;

fig. 9 is a schematic structural diagram of a chip according to an embodiment of the application.

Detailed Description

In order to clearly describe the technical solution of the embodiments of the present application, in the embodiments of the present application, the words "first", "second", etc. are used to distinguish the same item or similar items having substantially the same function and effect. For example, the first chip and the second chip are merely for distinguishing different chips, and the order of the different chips is not limited. It will be appreciated by those of skill in the art that the words "first," "second," and the like do not limit the amount and order of execution, and that the words "first," "second," and the like do not necessarily differ.

It should be noted that, in the embodiments of the present application, words such as "exemplary" or "such as" are used to mean serving as an example, instance, or illustration. Any embodiment or design described herein as "exemplary" or "for example" should not be construed as preferred or advantageous over other embodiments or designs. Rather, the use of words such as "exemplary" or "such as" is intended to present related concepts in a concrete fashion.

In the embodiments of the present application, "at least one" means one or more, and "a plurality" means two or more. "and/or", describes an association relationship of an association object, and indicates that there may be three relationships, for example, a and/or B, and may indicate: a alone, a and B together, and B alone, wherein a, B may be singular or plural. The character "/" generally indicates that the context-dependent object is an "or" relationship. "at least one of" or the like means any combination of these items, including any combination of single item(s) or plural items(s). For example, at least one (one) of a, b, or c may represent: a, b, c, a-b, a-c, b-c, or a-b-c, wherein a, b, c may be single or plural.

High availability (high availability) is often used to describe a system that has been specifically designed to reduce downtime while maintaining a high availability of its services. When the service system fails, the service can be continuously provided by using the backup service system by starting the backup service system, but a certain time may be generally consumed for starting the backup service system.

Based on the above, the service system is deployed in a distributed architecture manner, and for the services of the same service type, the service system provided in the embodiment of the present application can simultaneously start corresponding processes at a plurality of nodes to process the services of the service type. Under the condition that one process fails, the service system can select the process started by other nodes to take over the service processed by the failed process, so that the quick switching of the service process is realized (also called as ensuring the high availability of the service system). The single-instance process usually has exclusivity on the used resources, and in order to ensure the correctness of service processing, the single-instance process only allows one single-instance process to process the service at the same time. In the single-instance process switching method provided by the embodiment of the application, a monitoring process and a single-instance process are deployed at each service node of the distributed system, and the monitoring process monitors and controls the running state of the single-instance process. The state of a single instance process in each service node is stored in the data nodes of the distributed system so as to realize the rapid switching of the service processes, and only one service process processes the service of one service type at the same time.

The single-instance process switching method of the embodiment of the application can be applied to a distributed system, and an exemplary schematic diagram of the distributed system is shown in fig. 1. The distributed system 10 shown in fig. 1 includes a data node 101 and a plurality of service nodes 102 (e.g., a first service node 102-1, a second service node 102-2, and a third service node 102-3 in fig. 1), with the service nodes 102 being communicable, with the data node 101 being communicable as well.

The data node 101 is configured to store a state of a process for processing the target service in each service node 102 and a heartbeat timestamp of each service node.

The service node 102 is configured to monitor a state of a process on which a target service is handled and a state of a process of a target service in each service node stored in the data node 101, and send a state update instruction to the data node 101, where the state update instruction is configured to instruct the data node 101 to update the state of a process of the target service corresponding to the service node 102 stored therein.

The service node 102 is further configured to send a heartbeat to the data node 101 and a state of a process on the service node 102 for processing the target service; the status of the heartbeat and the progress of the target traffic is used for the data node 101 to record the heartbeat of the traffic node 102 and the status of the progress of the target traffic on the traffic node 102.

Optionally, the service node 102 is further configured to send a connection test message to the other service nodes 102, where the connection test message is used by the service node 102 to determine whether the other service nodes 102 are down. As in fig. 1, the first service node 102-1 sends a ping message to the second service node 102-2, where the ping message is used to obtain a response message, where the response message is used to characterize a connection timeout, the first service node 102-1 determines that the second service node 102-2 is in a non-connected state with the first service node 102-1, and where the response message is used to characterize receipt of a return data packet, the first service node 102-1 determines that the second service node 102-2 is in a normal networking state.

It should be understood that the functions of the data node 101 and any service node 102 may be integrated in one electronic device, or the functions of the data node 101 and the service node 102 may be implemented separately by different devices, which is not limited in the embodiment of the present application.

The functions of the data node 101 and the service node 102 described above may be implemented by the electronic device 20 as shown in fig. 2. The electronic device 20 in fig. 2 includes, but is not limited to: processor 201, memory 202, communication interface 203, and power supply 204, among others.

The processor 201 is a control center of the electronic device, connects various parts of the entire electronic device using various interfaces and lines, and performs various functions of the electronic device and processes data by running or executing software programs and/or modules stored in the memory 202, and calling data stored in the memory 202, thereby performing overall monitoring of the electronic device. The processor 201 may include one or more processing units; alternatively, the processor 201 may integrate an application processor that primarily handles operating systems, user interfaces, applications, etc., with a modem processor that primarily handles wireless communications. It will be appreciated that the modem processor described above may not be integrated into the processor 201.

The memory 202 may be used to store software programs as well as various data. The memory 202 may mainly include a storage program area that may store an operating system, application programs required for at least one functional unit, and the like, and a storage data area. In addition, memory 202 may include high-speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other volatile solid-state storage device. Alternatively, the memory 202 may be a non-transitory computer readable storage medium, such as read-only memory (ROM), random-access memory (random access memory, RAM), CD-ROM, magnetic tape, floppy disk, optical data storage device, and the like. Illustratively, the memory 202 stores a state of a process in each service node for processing the target service, a heartbeat time stamp of each service node, a heartbeat of a process in each service node, and a heartbeat of each service node.

The communication interface 203 is an interface through which an external device is connected to the electronic apparatus 20. For example, the external devices may include a wired or wireless headset port, an external power (or battery charger) port, a wired or wireless data port, a memory card port, a port for connecting a device having an identification module, an audio input/output (I/O) port, a video I/O port, an earphone port, and the like. The communication interface 203 may be used to receive input (e.g., data information, etc.) from an external device and transmit the received input to one or more elements within the electronic apparatus 20 or may be used to transmit data between the electronic apparatus 20 and an external device.

A power supply 204 (e.g., a battery) may be used to power the various components, and optionally, the power supply 204 may be logically connected to the processor 201 through a power management system, so as to perform functions of managing charging, discharging, and power consumption management through the power management system.

Optionally, the electronic device 20 provided in the embodiment of the present application further includes: display 205 and input device 206, display 205 may be a liquid crystal display (liquid crystal display, LCD), a light emitting diode (light emitting diode, LED) display device, a Cathode Ray Tube (CRT) display device, or a projector (projector), etc.

The input device 206 is in communication with the processor 201 and may receive user input in a variety of ways. For example, the input device 206 may be a mouse, a keyboard, a touch screen device, a sensing device, or the like.

Alternatively, the computer instructions in the embodiments of the present application may be referred to as application program codes or systems, and the embodiments of the present application are not limited thereto in particular.

It should be noted that the electronic device shown in fig. 2 is only an example, and is not limited to the electronic device configuration applicable to the embodiment of the present application. In actual implementation, the electronic device may include more or fewer devices or components than those shown in FIG. 2.

Fig. 3 is a flow chart of a single-instance process switching method according to an embodiment of the present application, where the single-instance process switching method shown in fig. 3 is applicable to the distributed system shown in fig. 1. As shown in fig. 3, the following steps may be included:

s100: the first service node reads the current state of the process of the target service in the first service node to obtain a first actual state.

In a possible implementation manner, a client monitoring process is deployed in the first service node, and the client monitoring process reads a current state of a process of a target service in the first service node to obtain a first actual state.

In one example, when a client monitoring process deployed in a first service node reads a process restart of a target service in the first service node, the first service node obtains a first actual state as a process restart state. The first actual state characterizes the process of the target service as being in the pre-preparation working state when the state of the process of the target service is the working state or the pre-preparation working state before the process is restarted, and characterizes the process of the target service as being in the idle state when the state of the process of the target service is the dead state or the idle state before the process is restarted.

In another example, when a client monitoring process deployed in a first service node reads a process death of a target service in the first service node, the first service node obtains a first actual state as a death state.

S101: and under the condition that the first actual state represents any one of an idle state, a dead state and a pre-preparation working state of the process of the target service, and the first previous state represents the process of the target service to be the working state, the first service node sends a first state change instruction to the data node. The first state change instruction is used for indicating the data node to update a first previous state, wherein the first previous state is the state of the process of the target service, which is recently recorded by the data node, in the first service node.

S102: and the data node updates the first pre-state into a process representing the target service into an idle state, a pre-preparation working state or a death state according to the first actual state and the first pre-state.

And under the condition that the first actual state is a death state and the first previous state is a working state, the data node updates the first previous state to represent the progress of the target service as the death state.

And under the condition that the first actual state is a process restarting state and the first previous state is a working state or the first previous state is a pre-preparation working state, the data node updates the first previous state to represent that the process of the target service is the pre-preparation working state.

And under the condition that the first actual state is a process restarting state and the first previous state is an idle state or the first previous state is a dead state, the data node updates the first previous state to be the idle state representing the process of the target service.

S103: the second service node reads a plurality of previous states from the data node and the current control node.

Based on the example of fig. 1, the second service node reads three pre-states from the data node, the first pre-state being a state of the process of the target service recorded by the data node in the first service node, the second pre-state being a state of the process of the target service recorded by the data node in the second service node, and the third pre-state being a state of the process of the target service recorded by the data node in the third service node. In one example, the second service node reads data at 8.8.6.22.2021.53 minutes and 40 seconds, and the first state of the second service node is a pre-ready state, the first state is a dead state, and the third state is an idle state.

In a possible implementation manner, the distributed system suitable for the embodiment of the application adopts a token ring network algorithm, so that each service node obtains the control right of the previous state recorded in the data node in turn. For example, the token identifier may be the same as the identifier of the service node, and the service node corresponding to the current token identifier is the current control node. And the service node corresponding to the current token identifier read by the second service node is the second service node.

S104: when the second front state is a pre-preparation working state, the current control node is a second service node, and the front states except the second front state in the plurality of front states are idle states or dead states, the second service node acquires heartbeat time stamps of nodes except the second service node in the plurality of service nodes in the data node; the heartbeat timestamp is used to characterize the time when the service node newly sent a heartbeat to the data node.

In a possible implementation manner, the second service node reads the heartbeat time stamp of each service node stored in the data node every preset time period.

In one example, the second service node reads the heartbeat time stamp of the first service node stored in the data node at 2021, 6, 22, 8, 53 minutes, 41 seconds, and the heartbeat time stamp of the third service node at 2021, 6, 22, 8, 53 minutes, 39 seconds.

S105: in the case that each heartbeat time stamp is later than the time when the second service node reads a plurality of previous states, the second service node sends a second state change instruction to the data node; the second state change instruction is for the data node to change the second pre-state to an operational state.

In a possible implementation manner, the second service node may read the heartbeat time stamps from each service node stored in the data node at intervals of a preset time period, and if the second service node determines that the heartbeat time stamps from each service node are all later than the time when the second service node reads a plurality of previous states, the second service node sends a second state change instruction to the data node. In this way, it can be ensured that no process of the target service in the other service node is in an operating state at that time.

Based on the example in S104, if the second service node reads the heartbeat time stamp stored in the data node five seconds after S104 reads the heartbeat time stamp of the first service node stored in the data node at 2021, 6, 22, 8, 53 minutes, 46 seconds, the heartbeat time stamp of the third service node at 2021, 6, 22, 8, 53 minutes, 45 seconds, the heartbeat time stamp of the third service node at 2021, 6, 22, 8, 53 minutes, 54 seconds. Since the heartbeat time stamp of the first service node is 2021, 6, 22, 8, 53 minutes and 45 seconds, and the heartbeat time stamp of the third service node is 2021, 6, 22, 8, 53 minutes and 54 seconds, which are all later than 2021, 6, 22, 8, 53 minutes and 40 seconds, the second service node sends a second state change instruction to the data node.

S106: the data node changes the second pre-state to an operational state.

S107: and under the condition that the second service node determines that the second previous state is the working state, the second service node operates the process of the target service to process the target service.

In a possible implementation manner, the second service node queries the second previous state in the data node again, so that the second service node runs the process of the target service to process the target service when the second previous state is the working state.

In the embodiment of the present application, a process of a target service in a first service node fails, for example: under the condition that the current state of the process of the target service in the first service node is in a dead state, the first service node can change the state (such as a first front state) of the process of the target service in the first service node recorded in the data node, so that under the condition that the current control node is a second service node, the first front state read by the second service node from the data node is an updated state, the front state of each service node read by the second service node does not comprise a working state, and under the condition that the second service node determines that the second front state is the only pre-preparation working state, the corresponding second front state can be changed into the working state to replace the process of the target service of the first service node to process the target service. Therefore, the single-instance process for processing the target service is efficiently switched from the first service node to the second service node.

Fig. 4 is a flow chart of a single-instance process state control method according to an embodiment of the present application, where the single-instance process state control method shown in fig. 4 is applicable to the distributed system shown in fig. 1. As shown in fig. 4, the following steps may be included:

s200: the second service node reads the previous state of each service node in the data node.

In a possible case, the first front state in the data node read by the second service node is a pre-preparation state, the second front state is a pre-preparation state, and the third front state is an idle state.

In another possible case, the first front state in the second service node reading data node is a pre-prepared working state, the second front state is a working state, and the third front state is a working state.

S201: and under the condition that the second service node determines that the current control node is the second service node, sending a third state change instruction to the data node, wherein the third state change instruction is used for changing the second previous state into the idle state by the data node.

The third state change instruction may comprise an identification of the second service node and an identification of the idle state.

S202: the data node changes the second pre-state to an idle state.

In a possible implementation manner, the data node reads the previous state corresponding to the identifier of the second service node from the stored multiple target corresponding relations, and updates the read previous state. The target corresponding relation is the corresponding relation between the identification of the service node and the previous state.

In this way, in the case that the number of pre-preparation work states or the number of pre-states of work states stored in the data node is greater than one, the current control node whose pre-state is the pre-preparation work state or the work state can instruct the data node to update its pre-state to the idle state, so that the situation that processes of two target services work simultaneously while the pre-preparation work state or the work state is stored in the data node is avoided.

Fig. 5 is a flow chart of another single-instance process state control method according to an embodiment of the present application, where the single-instance process state control method shown in fig. 5 is applicable to the distributed system shown in fig. 1. As shown in fig. 5, the following steps may be included:

s300: the second service node reads the previous state of each service node in the data node.

Illustratively, each previous state in the second service node read data node is an idle state.

S301: and under the condition that the second service node determines that the current control node is the second service node, sending a fourth state change instruction to the data node, wherein the fourth state change instruction is used for changing the second previous state into the pre-preparation working state by the data node.

The fourth state change instruction may comprise an identification of the second service node and an identification of the idle state.

S302: the data node changes the second pre-state to the pre-ready state.

In the embodiment of the application, under the condition that the previous states stored in the data node are idle states, the current control node can instruct the data node to update the corresponding previous state to the pre-prepared working state, so that the current control node can conveniently execute the target service.

Fig. 6 is a flowchart of another single-instance process state control method according to an embodiment of the present application, where the single-instance process state control method shown in fig. 6 is applicable to the distributed system shown in fig. 1. As shown in fig. 6, the following steps may be included:

S400: the target service node receives the target instruction. The target instruction is used for indicating the target service node to update the front state of the target service node in the data node; the target instruction includes a specified pre-state. The target service node may be any service node in the distributed system.

In a possible implementation, the target service node receives a target instruction from the user. The target service node may receive the target instruction input by the user through a graphical user interface of the target service node.

S401: the target service node sends a fifth state change instruction to the data node. The fifth state change instruction is for the data node to update a previous state of the target service node in the data node.

The fifth state change instruction may include an identification of the target service node and a specified previous state.

In one example, the fifth state change instruction includes an identification of the first service node and the pre-readiness state.

S402: the data node updates the previous state of the target service node in the data node to the specified previous state.

Based on the example in S401, the data node updates the first pre-state of the first service node in the data node to a pre-ready state.

In the embodiment of the application, the target service node can receive the instruction from the user or the instruction from other equipment so as to update the front state corresponding to the target service node stored in the data node.

Fig. 7 is a flowchart of another single-instance process state control method according to an embodiment of the present application, where the single-instance process state control method shown in fig. 7 is applicable to the distributed system shown in fig. 1. As shown in fig. 7, the following steps may be included:

s500: and the target service node sends a control node updating instruction to the data node under the condition that the heartbeat time stamp of the current control node in the data node and the duration of the current time are larger than a preset threshold value, wherein the control node updating instruction is used for updating the current control node into the target service node by the data node. The target service node may be any service node in a distributed system.

In one possible implementation, the target service node determines the current control node, queries a target heartbeat timestamp of the current control node in the data node, and obtains a difference value between the target heartbeat timestamp and the current time. And under the condition that the acquired difference value is larger than a preset threshold value, sending a connection test message to the current control node to obtain a test result, and under the condition that the test result is used for representing that the current control node and the target service node are in a disconnected state, sending a control node update instruction to the data node by the target service node.

In another possible implementation manner, the target service node queries whether the process of the target service in the data node of the current control node is overtime, if so, the target service node sends a connection test message to the current control node to obtain a test result, and if the test result is used for representing that the current control node is disconnected from the target service node, the target service node sends a control node update instruction to the data node.

It can be understood that whether the process of the target service in each service node is overtime can be stored in the data node, where the service node indicates that the data node updates the process of the target service corresponding to the service node to be overtime when the process of the target service in any service node is normal and overtime, where the service node indicates that the data node updates the process of the target service corresponding to the service node to be overtime when the process of the target service in any service node is normal and not overtime, and where the service node indicates that the data node updates the process of the target service corresponding to the service node to be overtime when the process of the target service in any service node is restarted or dead.

S501: the data node updates the current control node recorded by the data node to the target service node.

In the embodiment of the application, any service node can take over the current control node as a new current control node under the condition that the current control node is down or out of connection, so as to realize the control of the front state stored in the data node.

The method according to the embodiment of the present application is described above with reference to fig. 3 to fig. 7, and a distributed system for performing the method according to the embodiment of the present application is described below. Those skilled in the art will appreciate that the methods and systems may be combined and referenced with each other, and that the distributed system provided by the embodiments of the present application may perform the steps in the push method described above.

Fig. 1 is a schematic structural diagram of a distributed system according to an embodiment of the present application, and the distributed system 10 shown in fig. 1 includes: data node 101 and M service nodes 102 (e.g., first service node 102-1, second service node 102-2, and third service node 102-3 in fig. 1), service nodes 102 may communicate with each other, and service nodes 102 may also communicate with data node 101. Storing M previous states in the data node 101; an nth previous state of the M previous states is a state of a process of the target service newly recorded by the data node 101 in the nth service node 102; the state comprises a working state, an idle state, a death state and a pre-preparation working state; n is a positive integer less than or equal to M; the process of the target service is a single instance process; the first service node 102-1 is configured to read a current state of a process of a target service in the first service node 102-1, to obtain a first actual state; when the first actual state represents that the process of the target service is in any one of an idle state, a dead state or a pre-preparation working state, and the process of the first previous state represents that the process of the target service is in a working state, the first service node 102-1 is configured to send a first state change instruction to the data node 101; the first state change instruction is used for indicating the data node to update the first previous state; the first previous state is the state of the process of the target service, which is newly recorded by the data node 101, in the first service node 102-1; the data node 101 is configured to update the first previous state to an idle state, a pre-preparation working state, or a death state representing a process of the target service according to the first actual state and the first previous state; the second service node 102-2 is configured to read M previous states and a current control node from the data node 101; in the case that the second previous state is a pre-preparation working state, the current control node is a second service node 102-2, and the previous state except the second previous state in the M previous states is an idle state or a dead state, the second service node 102-2 is configured to obtain a heartbeat timestamp of a node except the second service node 102-2 in the M service nodes 102 in the data node 101; the heartbeat timestamp is used to characterize the time when the service node 102 newly transmits a heartbeat to the data node 101; the second service node 102-2 is configured to send a second state change instruction to the data node 101 if each heartbeat timestamp is later than a time when the second service node 102-2 reads M previous states; the second state change instruction is used for changing the second previous state to the working state by the data node 101; the data node 101 is configured to change the second previous state to an operating state; the second service node 102-2 is configured to, in case that the second previous state is determined to be the working state, operate a process of the target service by the second service node 102-2 to process the target service. For example: in connection with fig. 3, a first service node 102-1 may be used to perform S100, S101. The data node 101 may be used to perform S102, S106 and the second service node 102-2 may be used to perform S103-S105, S107.

Optionally, in the case that the first actual state is used to represent the process of the target service is restarted, and the first previous state is used to represent the process of the target service is a working state, the data node 101 is used to determine that the new first previous state is used to represent the process of the target service is a pre-preparation working state.

Alternatively, in the case that the first actual state is used to represent the process death of the target service, and the first previous state is used to represent the process of the target service is the working state, the data node 101 determines that the new first previous state is used to represent the process of the target service as the death state.

Optionally, in the case that the second previous state is the preparation operation state, at least one other previous state is the preparation operation state, and the current control node is the second service node 102-2, or in the case that the second previous state is the operation state, at least one other previous state is the operation state, and the current control node is the second service node 102-2, the second service node 102-2 is configured to send a third state change instruction to the data node 101; the third state change instruction is for the data node 101 to change the second previous state to the idle state; wherein the other front states are front states other than the first front state and the second front state among the M front states; the data node 101 is arranged to change the second pre-state to an idle state.

Optionally, in the case that the M previous states are all idle states and the current control node is the third service node 102-3, the third service node 102-3 sends a fourth state change instruction to the data node 101; the fourth state change instruction is used for changing the third previous state to the pre-preparation working state by the data node 101; the data node 101 changes the third previous state to the pre-ready state.

Optionally, any service node 102 of the M service nodes 102 is configured to receive a target instruction; the target instruction is used for indicating any service node 102 to update the previous state of any service node 102 in the data node 101; the target instruction includes a specified pre-state; any service node 102 is configured to send a fourth state change instruction to the data node 101; the fourth state change instruction is used for the data node 101 to update the previous state of any service node 102 in the data node 101; the data node 101 is configured to update a previous state of any service node 102 in the data node 101 to a specified previous state.

Optionally, in a case that any service node 102 of the M service nodes 102 determines that a time length between a heartbeat time stamp of a current control node in the data node 101 and a current time is greater than a preset threshold, any service node 102 sends a control node update instruction to the data node 101; the control node update instruction is used for updating the current control node into any service node 102 by the data node 101; the data node 101 updates its recorded current control node to any service node 102.

The distributed system of the present embodiment may be correspondingly used to perform the steps performed in the foregoing method embodiments, and the implementation principle and technical effects are similar, which are not described herein again.

As shown in fig. 8, a single instance process switching device 80 according to an embodiment of the present application may include at least one processor 801 and a memory 802, for example, the processor 201 in fig. 2. Each of these processors 801 may be a single-core (single-CPU) processor or may be a multi-core (multi-CPU) processor. A processor herein may refer to one or more devices, circuits, and/or processing cores for processing data (e.g., computer program instructions). Memory 802 may be memory 202 in fig. 2. Memory 802 is used to store code instructions; the processor 801 is configured to execute the code instructions to perform the method performed by the data node or the service node in the single instance process switching method provided in any of the embodiments described above.

Fig. 9 is a schematic structural diagram of a chip according to an embodiment of the present application. Chip 120 includes one or more (including two) processors 1210, communication lines 1220, and a communication interface 1230.

In some implementations, memory 1240 stores the following elements: executable modules or data structures, or a subset thereof, or an extended set thereof.

The methods described above for embodiments of the present application may be applied to the processor 1210 or implemented by the processor 1210. Processor 1210 may be an integrated circuit chip with signal processing capabilities. In implementation, the steps of the methods described above may be performed by integrated logic circuitry in hardware in processor 1210 or by instructions in software. The processor 1210 may be a general purpose processor (e.g., a microprocessor or a conventional processor), a digital signal processor (digital signal processing, DSP), an application specific integrated circuit (application specific integrated circuit, ASIC), an off-the-shelf programmable gate array (field-programmable gate array, FPGA) or other programmable logic device, discrete gates, transistor logic, or discrete hardware components, and the processor 1210 may implement or perform the methods, steps, and logic blocks disclosed in embodiments of the application.

The steps of the method disclosed in connection with the embodiments of the present application may be embodied directly in the execution of a hardware decoding processor, or in the execution of a combination of hardware and software modules in a decoding processor. The software modules may be located in a state-of-the-art storage medium such as random access memory, read-only memory, programmable read-only memory, or charged erasable programmable memory (electrically erasable programmable read only memory, EEPROM). The storage medium is located in a memory 1240 and the processor 1210 reads information in the memory 1240 and performs the steps of the method described above in connection with its hardware.

Communication between processor 1210, memory 1240, and communication interface 1230 may be via communication lines 1220.

In the above embodiments, the instructions stored by the memory for execution by the processor may be implemented in the form of a computer program product. The computer program product may be written in the memory in advance, or may be downloaded in the form of software and installed in the memory.

Embodiments of the present application also provide a computer program product comprising one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the processes or functions in accordance with embodiments of the present application are produced in whole or in part. The computer may be a general purpose computer, a special purpose computer, a computer network, or other programmable apparatus. The computer instructions may be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another computer-readable storage medium, for example, the computer instructions may be transmitted from one website, computer, server, or data center to another website, computer, server, or data center by wired (e.g., coaxial cable, fiber optic, digital subscriber line (digital subscriber line, DSL), or wireless (e.g., infrared, wireless, microwave, etc.), or semiconductor medium (e.g., solid state disk, SSD)) or the like.

The embodiment of the application also provides a computer readable storage medium. The methods described in the above embodiments may be implemented in whole or in part by software, hardware, firmware, or any combination thereof. Computer readable media can include computer storage media and communication media and can include any medium that can transfer a computer program from one place to another. The storage media may be any target media that is accessible by a computer.

As one possible design, the computer-readable medium may include compact disk read-only memory (CD-ROM), RAM, ROM, EEPROM, or other optical disk memory; the computer readable medium may include disk storage or other disk storage devices. Moreover, any connection is properly termed a computer-readable medium. For example, if the software is transmitted from a website, server, or other remote source using a coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio, and microwave, then the coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio, and microwave are included in the definition of medium. Disk and disc, as used herein, includes Compact Disc (CD), laser disc, optical disc, digital versatile disc (digital versatile disc, DVD), floppy disk and blu-ray disc where disks usually reproduce data magnetically, while discs reproduce data optically with lasers.

Combinations of the above should also be included within the scope of computer-readable media. The foregoing is merely illustrative of the present invention, and the present invention is not limited thereto, and any person skilled in the art will readily recognize that variations or substitutions are within the scope of the present invention. Therefore, the protection scope of the invention is subject to the protection scope of the claims.

Claims

1. A single instance process switching method, characterized by being applied to a distributed system, the distributed system comprising: a data node and M service nodes; m is a positive integer; storing M previous states in the data node; the Nth previous state in the M previous states is the state of the process of the target service, which is recorded by the data node, in the Nth service node; the states comprise a working state, an idle state, a death state and a pre-preparation working state; n is a positive integer less than or equal to M; the process of the target service is a single instance process; the method comprises the following steps:

the first service node reads the current state of the process of the target service in the first service node to obtain a first actual state;

When the first actual state represents that the process of the target service is in any one of the idle state, the dead state or the pre-preparation working state and the first previous state represents that the process of the target service is in the working state, the first service node sends a first state change instruction to the data node; the first state change instruction is configured to instruct the data node to update the first previous state; the first previous state is the state of the process of the target service, which is newly recorded by the data node, in the first service node;

the data node updates the first pre-state into the idle state, the pre-preparation working state or the death state representing the process of the target service according to the first actual state and the first pre-state;

the second service node reads the M previous states and the current control node from the data node; when the second previous state is the pre-preparation working state, the current control node is the second service node, and the previous states except the second previous state in the M previous states are the idle state or the dead state, the second service node obtains heartbeat time stamps of nodes except the second service node in the M service nodes in the data node; the heartbeat time stamp is used for representing the latest heartbeat sending time of the service node to the data node;

In the case that each heartbeat time stamp is later than the time when the second service node reads the M previous states, the second service node sends a second state change instruction to the data node; the second state change instruction is used for changing the second previous state into the working state by the data node;

the data node changes the second previous state into the working state;

and under the condition that the second service node determines that the second pre-state is the working state, the second service node operates the process of the target service to process the target service.

2. The method according to claim 1, wherein the data node updates the first pre-state to characterize the progress of the target traffic as the idle state, the pre-ready state, or the dead state based on the first actual state and the first pre-state; comprising the following steps:

and under the condition that the first actual state is used for representing the process of the target service and the first previous state is used for representing the process of the target service as the working state, the data node determines that the new first previous state is used for representing the process of the target service as the pre-preparation working state.

3. The method according to claim 1, wherein the data node updates the first pre-state to characterize the progress of the target traffic as the idle state, the pre-ready state, or the dead state based on the first actual state and the first pre-state; comprising the following steps:

and under the condition that the first actual state is used for representing the process death of the target service and the first previous state is used for representing the process of the target service as the working state, the data node determines that the new first previous state is used for representing the process of the target service as the death state.

4. A method according to any one of claims 1-3, wherein the method further comprises:

in case the second pre-state is the pre-preparation state, at least one other pre-state is the pre-preparation state, and the current control node is the second service node, or in case the second pre-state is the working state, at least one of the other pre-states is the working state, and the current control node is the second service node,

The second service node sends a third state change instruction to the data node; the third state change instruction is configured to change the second previous state to the idle state by the data node; wherein the other front states are front states other than the first front state and the second front state among the M front states;

the data node changes the second pre-state to the idle state.

5. The method according to claim 4, wherein the method further comprises:

when the M previous states are all the idle states and the current control node is a third service node, the third service node sends a fourth state change instruction to the data node; the fourth state change instruction is used for changing a third previous state into the pre-preparation working state by the data node;

the data node changes the third pre-state to the pre-preparation state.

6. The method according to claim 4, wherein the method further comprises:

any service node in the M service nodes receives a target instruction; the target instruction is used for indicating the any service node to update the front state of the any service node in the data node; the target instruction includes a specified pre-state;

The any service node sends a fifth state change instruction to the data node; the fifth state change instruction is used for the data node to update the front state of any service node in the data node;

the data node updates the previous state of any service node in the data node to the appointed previous state.

7. The method according to claim 4, wherein the method further comprises:

in case any one of the M service nodes determines that the duration of the heartbeat timestamp and the current time of the current control node in the data node is greater than a preset threshold,

any service node sends a control node update instruction to a data node; the control node updating instruction is used for the data node to update the current control node to any service node;

and the data node updates the current control node recorded by the data node into any service node.

8. A distributed system comprising a data node and M service nodes; m is a positive integer; storing M previous states in the data node; the Nth previous state in the M previous states is the state of the process of the target service, which is recorded by the data node, in the Nth service node; the states comprise a working state, an idle state, a death state and a pre-preparation working state; n is a positive integer less than or equal to M; the process of the target service is a single instance process;

The first service node is used for reading the current state of the process of the target service in the first service node to obtain a first actual state;

when the first actual state represents that the process of the target service is in any one of the idle state, the dead state or the pre-preparation working state, and the first previous state represents that the process of the target service is in the working state, the first service node is used for sending a first state change instruction to the data node; the first state change instruction is configured to instruct the data node to update the first previous state; the first previous state is the state of the process of the target service, which is newly recorded by the data node, in the first service node;

the data node is configured to update the first previous state to represent the process of the target service as the idle state, the pre-preparation working state or the death state according to the first actual state and the first previous state;

the second service node is used for reading the M previous states and the current control node from the data node; when the second previous state is the pre-preparation working state, the current control node is the second service node, and the previous states except the second previous state in the M previous states are the idle state or the dead state, the second service node is configured to obtain a heartbeat timestamp of a node except the second service node in the M service nodes in the data node; the heartbeat time stamp is used for representing the latest heartbeat sending time of the service node to the data node;

The second service node is configured to send a second state change instruction to the data node when each of the heartbeat timestamps is later than a time when the second service node reads the M previous states; the second state change instruction is used for changing the second previous state into the working state by the data node;

the data node is used for changing the second previous state into the working state;

and the second service node is used for running the process of the target service to process the target service under the condition that the second pre-state is determined to be the working state.

9. A computer readable storage medium storing instructions that, when executed, cause a computer to perform the single instance process switching method of any one of claims 1 to 7.