CN113342496A - Single-instance process switching method, system and storage medium - Google Patents

Abstract

The embodiment of the application provides a method, a system and a storage medium for switching a single instance process, which relate to the technical field of computers and comprise the following steps: when 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, when the current control node is the second service node, the second service node reads the previous state of each service node from the data node, namely the updated state, the read previous state of the second service node does not comprise the working state, and when the second service node determines that the second previous state is the only pre-preparation working state, the corresponding second previous state is changed into the working state so as to take over 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 switching the single-instance process 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 method, a system and a storage medium for switching single-instance processes.

Background

A single-instance process is a single-instance process, one instance process may be used to process a service, and a single-instance process typically has exclusivity with respect to resources (e.g., data resources) used by the single-instance process. Therefore, the single-instance process for processing the same type of service cannot be executed concurrently, and when the single-instance process for processing the service is abnormal, the service needs to be quickly switched to another single-instance process for processing.

At present, in order to ensure the availability of a service system in which 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, and services are processed by using the backup service system.

The manual start 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 start time, resulting in long service switching time.

Disclosure of Invention

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

In a first aspect, an embodiment of the present application provides a single-instance process switching method, which is 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; the Nth previous state in the M previous states is the state of the process of the target service, which is newly 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 process of the first actual state representation target service is in any one of an idle state, a death state or a pre-preparation working state, and the process of the first previous state representation 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 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 previous state into a state representing that the process of the target service is an idle state, a pre-preparation working state or a death state according to the first actual state and the first previous state; the second service node reads M previous states and the current control node from the data node; when the second previous state is a pre-preparation working state, the current control node is a second service node, 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 acquires heartbeat timestamps of the nodes except the second service node in the M service nodes in the data node; the heartbeat timestamp is used for representing the latest heartbeat sending time of the service node to the data node; under the condition that each heartbeat timestamp is later than the time for reading the 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 the second service node runs the process of the target service to process the target service under the condition that the second previous state is determined to be the working state by the second service node.

In the embodiment of the present application, in case of a failure of the process of the target service in the first service node (for example, in case that 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 or a pre-preparation working state), the first service node may change the state of the progress of the target service in the first service node (e.g., the first previous state) recorded in the data node, and as such, when the current control node is the second service node, the first previous state read by the second service node from the data node is the updated state, and the previous state read by the second service node does not include the working state, so that when the second service node determines that the second previous state is the only pre-preparation working state, the corresponding second previous state can be changed into the working state to take over 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, according to the first actual state and the first previous state, updating the first previous state to a state in which a process representing the target service is an idle state, a pre-preparation working state, or a dead state, and includes: and under the condition that 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 determines that the new first previous state is used for representing the process of the target service as the pre-preparation working state.

Therefore, under the condition that the process of the target service is restarted, the data node can update the first previous state stored by the data node to be the pre-preparation working state in time, and the service node accessed subsequently can take over the target service processed by the first service node conveniently.

In another possible implementation manner, the updating, by the data node, the first previous state to a state in which the process representing the target service is an idle state, a pre-preparation working state, or a dead state according to the first actual state and the first previous state includes: and under the condition that the first actual state is used for representing that the process of the target service is dead and the first previous state is used for representing that the process of the target service is in a working state, the data node determines that the new first previous state is used for representing that the process of the target service is in a dead state.

Therefore, when the process of the target service is dead (for example, the process of the target service is dead or the first service node is down), the data node can update the first previous state stored by the data node to be the dead state in time, so that the subsequently accessed service node can take over the target service processed by the first service node conveniently.

In another possible implementation manner, the method further includes: when the second previous state is a pre-preparation working state, at least one other previous state is a pre-preparation working state, and the current control node is a second service node, or when the second previous state is a working state, at least one other previous 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 previous states are previous states other than the first previous state and the second previous state among the M previous states; the data node changes the second previous state to an idle state.

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

In another possible implementation manner, the method further includes: 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 previous state to a pre-prepare operational state.

In this way, when the previous states stored in the data node are all idle states, the current control node may instruct the data node to update its corresponding previous state to a pre-preparation working state, so that the current control node can execute the target service.

In another possible implementation manner, the method further includes: any service node in the M service nodes receives a target instruction; the target instruction is used for instructing any service node to update the previous 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 the data node to update the previous 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 a designated previous state.

In this way, any service node may also receive instructions from a 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: under the condition that any service node in the M service nodes determines that the duration of the heartbeat timestamp of the current control node in the data node and the current time is greater than a preset threshold value, any service node sends a control node updating 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.

Therefore, under the condition that the current control node is down or lost, any service node can take over as a new current control node to realize the control of the previous state stored in the data node.

In a second aspect, a distributed system is provided, 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; the Nth previous state in the M previous states is the state of the process of the target service, which is newly 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 process of the first actual state representation target service is in any one of an idle state, a death state or a pre-preparation working state, and the process of the first previous state representation 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 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 previous state into a state representing that the process of the target service is an idle state, a pre-preparation working state or a death state according to the first actual state and the first previous state; the second service node is used for reading M previous states and the current control node from the data node; when the second previous state is a pre-preparation working state, the current control node is a second service node, 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 is used for acquiring heartbeat timestamps of the nodes except the second service node in the M service nodes in the data node; the heartbeat timestamp 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 timestamp is later than the time for the second service node to read 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 front 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 previous state is determined to be the working state.

Optionally, when the process in the first actual state used for representing the target service is restarted and the process in the first previous state used for representing the target service is in the working state, the data node is configured to determine that the process in the new first previous state used for representing the target service is in the pre-preparation working state.

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

Optionally, when the second previous state is a pre-preparation working state, at least one other previous state is a pre-preparation working state, and the current control node is a second service node, or when the second previous state is a working state, at least one other previous state is a working state, and the current control node is a 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 previous states are previous states other than the first previous state and the second previous state among the M previous states; the data node is configured to change the second previous 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 previous state to a pre-prepare operational state.

Optionally, any service node of the M service nodes is configured to receive the target instruction; the target instruction is used for instructing any service node to update the previous 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 the data node to update the previous state of any service node in the data node; the data node is used for updating the previous state of any service node in the data node to a specified previous state.

Optionally, when any service node of the M service nodes determines that the duration of the heartbeat timestamp of the current control node in the data node and the current time is greater than a preset threshold, 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, where the memory is used to store code instructions, and the processor is used to execute the code instructions to execute a method executed by any service node or data node in a single-instance switching method described in the first aspect or any one of possible implementation manners of the first aspect.

In a fourth aspect, an embodiment of the present application provides a computer-readable storage medium, where a computer program or an instruction is stored in the computer-readable storage medium, and when the computer program or the instruction runs on a computer, the computer is caused to execute a method executed by any service node or data node in a single-instance handover method described in the first aspect or any one of the possible implementation manners of the first aspect.

In a fifth aspect, an embodiment of the present application provides a computer program product including a computer program, which, when the computer program runs on a computer, causes the computer to execute the method performed by any service node or data node in a 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 a chip system, where the chip or the chip system includes at least one processor and a communication interface, where the communication interface and the at least one processor are interconnected by a line, and the at least one processor is configured to execute a computer program or an instruction to execute a method executed by any service node or data node in a single-instance handover method described in the first aspect or any one of possible implementation manners of the first aspect; the communication interface in the chip may be an input/output interface, a pin, a circuit, or the like.

In one possible implementation, the chip or chip system described above in this application further comprises at least one memory having instructions stored therein. The memory may be a storage unit inside the chip, such as a register, a cache, etc., or may be a storage 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 beneficial effects achieved by the aspects and the corresponding possible implementations are similar and will not be described again.

Drawings

Fig. 1 is a schematic structural 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 schematic flowchart of a single-instance process switching method according to an embodiment of the present application;

fig. 4 is a schematic flowchart of a single-instance process state control method according to an embodiment of the present application;

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

fig. 6 is a schematic flowchart of another single-instance process state control method according to an embodiment of the present application;

fig. 7 is a schematic flowchart of another single-instance process state control method according to an embodiment of the present application;

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

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

Detailed Description

In the embodiments of the present application, terms such as "first" and "second" are used to distinguish the same or similar items having substantially the same function and action. For example, the first chip and the second chip are only used for distinguishing different chips, and the sequence order thereof is not limited. Those skilled in the art will appreciate that the terms "first," "second," etc. do not denote any order or quantity, nor do the terms "first," "second," etc. denote any order or importance.

It should be noted that in the embodiments of the present application, words such as "exemplary" or "for example" are used to indicate examples, illustrations or explanations. Any embodiment or design described herein as "exemplary" or "e.g.," is not necessarily to be construed as preferred or advantageous over other embodiments or designs. Rather, use of the word "exemplary" or "such as" is intended to present concepts related in a concrete fashion.

In the embodiments of the present application, "at least one" means one or more, "a plurality" means two or more. "and/or" describes the association relationship of the associated objects, meaning that there may be three relationships, e.g., a and/or B, which may mean: a exists alone, A and B exist simultaneously, and B exists alone, wherein A and B can be singular or plural. The character "/" generally indicates that the former and latter associated objects are in an "or" relationship. "at least one of the following" or similar expressions refer to any combination of these items, including any combination of the singular or plural items. 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 multiple.

High availability (high availability) is often used to describe a system that is specially designed to reduce downtime while maintaining a high availability of its services. When a service system fails, a backup service system can be started to continue providing services by using the backup service system, but it may usually take a certain time to start the backup service system.

Based on this, the service system is deployed in a distributed architecture manner, and for services of the same service type, the service system provided in the embodiment of the present application can start corresponding processes at multiple nodes at the same time to process the services of the service type. Under the condition that one process has a fault, the service system can select a process started by other nodes to take over the service processed by the fault process, so that the rapid switching of the service process is realized (also called ensuring the high availability of the service system). The single-instance process usually has exclusivity to the used resources, and in order to guarantee 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 a distributed system, and the monitoring process monitors and controls the running state of the single-instance process. The state of the single instance process in each service node is stored in the data node of the distributed system, so that the rapid switching of the service processes is realized, 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 present application may be applied to a distributed system, and for example, fig. 1 is a schematic structural diagram of the distributed system provided in the embodiment of the present application. 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), where the service nodes 102 may communicate with each other and the service nodes 102 may communicate with the data node 101.

The data node 101 is configured to store a state of a process of processing a 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 the target service is processed and a state of a process of the 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 used to instruct the data node 101 to update a state of a process, stored in the data node, of the target service corresponding to the service node 102, for processing the target service.

The service node 102 is further configured to send the heartbeat and the state of the process of processing the target service on the service node 102 to the data node 101; the status of the heartbeat and the progress of the target service is used for the data node 101 to record the status of the heartbeat of the service node 102 and the progress of the target service on the service 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 for the service node 102 to determine whether the other service nodes 102 are down. As in fig. 1, first service node 102-1 sends a ping message to second service node 102-2, where the ping message is used to obtain a response message, where first service node 102-1 determines that second service node 102-2 is in a non-connected state with first service node 102-1 where the response message is used to characterize a connection timeout, and where the response message is used to characterize a receipt of a return data packet, first service node 102-1 determines that second service node 102-2 is in a normal networking state.

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

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

The processor 201 is a control center of the electronic device, connects various parts of the whole electronic device by 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. Processor 201 may include one or more processing units; optionally, the processor 201 may integrate an application processor and a modem processor, wherein the application processor mainly handles operating systems, user interfaces, application programs, and the like, and the modem processor mainly 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 program storage area and a data storage area, wherein the program storage area may store an operating system, an application program required by at least one functional unit, and the like. Further, the 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, for example, a read-only memory (ROM), a Random Access Memory (RAM), a CD-ROM, a magnetic tape, a floppy disk, an optical data storage device, and the like. Illustratively, the memory 202 stores the state of the process of processing the target service in each service node, the heartbeat timestamp of each service node, the heartbeat of the process in each service node, the heartbeat of each service node, and the like.

The communication interface 203 is an interface for connecting an external device to the electronic apparatus 20. For example, the external device may include a wired or wireless headset port, an external power supply (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 source 204 (e.g., a battery) may be used to supply power to each component, and optionally, the power source 204 may be logically connected to the processor 201 through a power management system, so as to implement functions of managing charging, discharging, and power consumption through the power management system.

Optionally, the electronic device 20 provided in the embodiment of the present application further includes: a display 205 and an input device 206, where the display 205 may be a Liquid Crystal Display (LCD), a Light Emitting Diode (LED) display device, a Cathode Ray Tube (CRT) display device, a projector (projector), or the like.

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, or a sensing device, among others.

Optionally, the computer instructions in the embodiments of the present application may also be referred to as application program code or system, which is not specifically limited in the embodiments of the present application.

The electronic device shown in fig. 2 is merely an example, and does not limit the electronic device to which the embodiments of the present application are applicable. In actual implementation, the electronic device may include more or fewer devices or devices than those shown in fig. 2.

Fig. 3 is a schematic flowchart 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 an example, when a client monitor 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. And when the state of the process of the target service before the process is restarted is a dead state or an idle state, the process of the target service is represented in the idle state.

In another example, when a client monitor process deployed in a first service node reads that a process of a target service in the first service node is dead, the first service node obtains a first actual state as a dead state.

S101: and when the process of the first actual state representation target service is in any one of an idle state, a death state or a pre-preparation working state, and the process of the first previous state representation 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 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 recorded by the data node latest, in the first service node.

S102: and the data node updates the first previous state into a state representing that the process of the target service is an idle state, a pre-preparation working state or a death state according to the first actual state and the first previous 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 into a process representing the target service, wherein the process represents 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 into a process representing the target service, wherein the process represents the target service, and the process represents 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 indicate that the process of the target service is an idle state.

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

Based on the example of fig. 1, the second service node reads three previous states from the data node, where the first previous state is a state of the process of the target service recorded by the data node in the first service node, the second previous state is a state of the process of the target service recorded by the data node in the second service node, and the third previous state is 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 the data node at 8: 53 min 40 sec on 22/2021, the previous state of the second service node is the pre-preparation working state, the first previous state is the death state, and the third previous state is the idle state.

In a possible implementation manner, the distributed system applied in the embodiment of the present application adopts a token ring 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 previous state is a pre-preparation working state, the current control node is a second service node, and the previous states except the second previous state in the plurality of previous states are idle states or dead states, the second service node acquires heartbeat timestamps of the nodes except the second service node in the plurality of service nodes in the data node; the heartbeat timestamp is used for representing the time when the service node sends heartbeat to the data node newly.

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

In one example, the heartbeat timestamp of the first service node stored in the data node read by the second service node at 53 minutes 41 seconds at 8 points on 22 and 22 months in 2021 is 53 minutes 40 seconds at 8 points on 22 and 22 months in 2021, and the heartbeat timestamp of the third service node is 53 minutes 39 seconds at 8 points on 22 and 8 months in 2021.

S105: under the condition that each heartbeat timestamp is later than the time for reading the plurality of 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 for the data node to change the second previous state to the working state.

In a possible implementation manner, the second service node may read the heartbeat timestamps from the service nodes stored in the data node at intervals of a preset time period, and send the second state change instruction to the data node when the second service node determines that the heartbeat timestamps from the service nodes are all later than the time for the second service node to read the previous states. In this way, it can be ensured that no processes of the target service in other service nodes are in an active state at that moment.

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

S106: the data node changes the second previous state to the active state.

S107: and the second service node runs the process of the target service to process the target service under the condition that the second previous state is determined to be the working state by the second service node.

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

In the embodiment of the present application, a process of a target service in a first service node fails, for example: in the case 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 may change the state (e.g., the first previous state) of the process of the target service in the first service node recorded in the data node, so that, when the current control node is the second service node, the first previous state read by the second service node from the data node is an updated state, and the previous state of each service node read by the second service node does not include a working state, and then, when the second service node determines that the second previous state is the only pre-preparation working state, the corresponding second previous state may be changed to the working state to process the target service in place of the process of the target service of the first service node. 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 schematic flowchart 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 nodes.

In one possible case, the first previous state in the second service node reading data node is a pre-preparation working state, the second previous state is a pre-preparation working state, and the third previous state is an idle state.

In another possible case, the first previous state in the second service node reading data node is a pre-preparation working state, the second previous state is a working state, and the third previous 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 an idle state by the data node.

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

S202: the data node changes the second previous 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 correspondence, and updates the read previous state. The target corresponding relation is the corresponding relation between the service node identifier and the previous state.

Thus, when the number of the pre-preparation working states or the previous states of the working states stored in the data node is more than one, the current control node with the previous state being the pre-preparation working state or the working state can instruct the data node to update the previous state to the idle state, so that the situation that more than one pre-preparation working state or working state is stored in the data node at the same time and the processes of two target services work at the same time is avoided.

Fig. 5 is a schematic 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. 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 nodes.

For example, the second service node reads each previous state in the data node as an idle state.

S301: and the second service node sends a fourth state change instruction to the data node under the condition that the current control node is determined to be the second service 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 previous state to a pre-prepare operational 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 correspondence, and updates the read previous state. The target corresponding relation is the corresponding relation between the service node identifier and the previous state.

In the embodiment of the present application, when the previous states stored in the data node are all idle states, the current control node may instruct the data node to update the previous state corresponding to the data node to a pre-preparation working state, so that the current control node executes a target service.

Fig. 6 is a schematic 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 instructing the target service node to update the previous 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 one of the service nodes in the distributed system.

In a possible implementation, the target service node receives a target instruction from a user. The target service node may receive a target instruction input by a 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 a pre-preparation operational state.

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

Based on the example in S401, the data node updates the first previous state of the first service node in the data node to the pre-preparation working state.

In this embodiment of the application, the target service node may receive an instruction from a user or an instruction from another device, so as to update the previous state corresponding to the target service node stored in the data node.

Fig. 7 is a schematic 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 duration of the heartbeat timestamp and the current time of the current control node in the data node is determined to be greater 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 one of the service nodes in the distributed system.

In a possible implementation manner, the target service node determines a 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 obtained difference value is greater 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 updating instruction to the data node by the target service node.

In another possible implementation manner, the target service node queries whether the progress of the target service of the current control node in the data node is overtime, if yes, the target service node sends 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, the target service node sends a control node update instruction to the data node.

It can be understood that, the data node may store whether the process of the target service in each service node is overtime, and when the process of the target service in any service node is normal and overtime, the service node instructs the data node to update the process of the target service corresponding to the service node to be overtime, and when the process of the target service in any service node is normal and not overtime, the service node instructs the data node to update the process of the target service corresponding to the service node to be not overtime, and when the process of the target service in any service node is restarted or dead, the service node instructs the data node to update the process of the target service corresponding to the service node to be not overtime.

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

In the embodiment of the application, under the condition that the current control node is down or lost, any service node can take over as a new current control node, so that the control of the previous state stored in the data node is realized.

The method of 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 provided by the embodiment of the present application is described below. Those skilled in the art will appreciate that the method and system can be combined and referred to each other, and the distributed system provided by the embodiments of the present application can 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, where a distributed system 10 shown in fig. 1 includes: a data node 101 and M 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), where the service nodes 102 may communicate with each other, and the service nodes 102 may communicate with the data node 101. Storing M previous states in data node 101; the nth previous state of the M previous states is a state of a process of a target service, which is newly recorded by the data node 101, in the nth service node 102; wherein 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 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 process of the first actual state representation target service is in any one of an idle state, a death state or a pre-preparation working state, and the process of the first previous state representation target service is in the 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 a state of a process of a 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 a state in which a process representing the target service is an idle state, a pre-preparation working state, or a death state 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; when 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 among 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 among the M service nodes 102 in the data node 101; the heartbeat timestamp is used for representing the latest heartbeat sending time of the service node 102 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 when each heartbeat timestamp is later than the time for the second service node 102-2 to read the M previous states; the second state change instruction is used for the data node 101 to change the second previous state into the working state; the data node 101 is configured to change the second previous state to the working state; the second service node 102-2 is configured to, when determining that the second previous state is the working state, run 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, the first service node 102-1 may be configured to perform S100, S101. The data node 101 may be configured to perform S102, S106, and the second service node 102-2 may be configured to perform S103 to S105, S107.

Optionally, when the process in the first actual state used for representing the target service is restarted and the process in the first previous state used for representing the target service is in the working state, the data node 101 is configured to determine that the process in the new first previous state used for representing the target service is in the pre-preparation working state.

Optionally, when the first actual state is used to characterize the process of the target service as dead, and the first previous state is used to characterize the process of the target service as working state, the data node 101 determines that the new first previous state is used to characterize the process of the target service as dead.

Optionally, when the second previous state is a pre-preparation working state, at least one other previous state is a pre-preparation working state, and the current control node is the second service node 102-2, or when the second previous state is a working state, at least one other previous state is a working 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 used for the data node 101 to change the second previous state into the idle state; wherein the other previous states are previous states other than the first previous state and the second previous state among the M previous states; the data node 101 is configured to change the second previous state to the idle state.

Optionally, when the M previous states are 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 the data node 101 to change the third previous state into a pre-preparation working state; the data node 101 changes the third previous state to the pre-preparation operating state.

Optionally, any service node 102 of the M service nodes 102 is configured to receive the target instruction; the target instruction is used to instruct 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 the previous state of any service node 102 in the data node 101 to a specified previous state.

Optionally, when any service node 102 of the M service nodes 102 determines that the duration of the heartbeat timestamp of the current control node in the data node 101 and the 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 the data node 101 to update the current control node to any service node 102; the data node 101 updates its recorded current control node to any of the service nodes 102.

The distributed system of this embodiment can be correspondingly used to execute the steps executed in the above method embodiments, and the implementation principle and technical effect are similar, which are not described herein again.

As shown in fig. 8, for a single-instance process switching apparatus provided in an embodiment of the present application, the single-instance process switching apparatus 80 may include at least one processor 801 and a memory 802, for example, the processor 201 in fig. 2. Each of the processors 801 may be a single-core (single-CPU) processor or 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). The memory 802 may be the memory 202 in fig. 2. The 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 above embodiments.

Exemplarily, fig. 9 is a schematic structural diagram of a chip provided in 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 embodiments, memory 1240 stores the following elements: an executable module or a data structure, or a subset thereof, or an expanded set thereof.

The methods described in the 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 having signal processing capabilities. In implementation, the steps of the above method may be performed by instructions in the form of hardware, integrated logic circuits, or software in the processor 1210. The processor 1210 may be a general-purpose processor (e.g., a microprocessor or a conventional processor), a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), an FPGA (field-programmable gate array) or other programmable logic device, discrete gate, transistor logic device or discrete hardware component, and the processor 1210 may implement or execute the methods, steps and logic blocks disclosed in the embodiments of the present invention.

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

Communication among the processor 1210, memory 1240 and communications interface 1230 may be via communications link 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. The procedures or functions according to the embodiments of the present application are all or partially generated when the computer program instructions are loaded and executed on a computer. The computer may be a general purpose computer, a special purpose computer, a network of computers, or other programmable device. Computer instructions may be stored in, or transmitted from, a computer-readable storage medium to another computer-readable storage medium, e.g., from one website, computer, server, or data center to another website, computer, server, or data center via wire (e.g., coaxial cable, fiber optics, Digital Subscriber Line (DSL), or wireless (e.g., infrared, wireless, microwave, etc.), the computer-readable storage medium may be any available medium that a computer can store or a data storage device including one or more available media integrated servers, data centers, etc., the available media may include, for example, magnetic media (e.g., floppy disks, hard disks, or magnetic tape), optical media (e.g., digital versatile disks, DVD), or a semiconductor medium (e.g., a Solid State Disk (SSD)), etc.

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 may include computer storage media and communication media, and may include any medium that can communicate a computer program from one place to another. A storage medium may be any target medium that can be accessed by a computer.

As one possible design, the computer-readable medium may include a compact disk read-only memory (CD-ROM), RAM, ROM, EEPROM, or other optical disk storage; the computer readable medium may include a disk memory or other disk storage device. Also, any connecting line may also be 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 (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 above description is only for the specific embodiments of the present invention, but the scope of the present invention is not limited thereto, and any person skilled in the art can easily conceive of the changes or substitutions within the technical scope of the present invention, and all the changes or substitutions should be covered within the scope of the present invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the claims.

Claims (10)

1. A single-instance process switching method is applied to a distributed system, and the distributed system comprises the following steps: 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 newly 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:

a 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 death state or the pre-preparation working state, and a 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 used for instructing 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 recorded by the data node latest, in the first service node;

the data node updates the first previous state into 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 reads the M previous states and the current control node from the data node; when a second previous state is the pre-preparation working state, the current control node is the second service node, and a previous state except the second previous state among the M previous states is the idle state or the dead state, the second service node obtains a heartbeat timestamp of a node except the second service node among the M service nodes in the data node; the heartbeat timestamp is used for representing the latest heartbeat sending time of the service node to the data node;

under the condition that each heartbeat timestamp is later than the time for reading the 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 to the working state;

and the second service node runs the process of the target service to process the target service under the condition that the second previous state is determined to be the working state by the second service node.

2. The method of claim 1, wherein the data node updates the first previous state to the idle state, the pre-preparation working state, or the death state according to the first actual state and the first previous state; the method comprises the following steps:

and 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 that the process of the target service is the working state, the data node determines that the new first previous state is used for representing that the process of the target service is the pre-preparation working state.

3. The method of claim 1, wherein the data node updates the first previous state to the idle state, the pre-preparation working state, or the death state according to the first actual state and the first previous state; the method comprises the following steps:

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

4. The method according to any one of claims 1-3, further comprising:

when the second previous state is the pre-preparation working state, at least one other previous state is the pre-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 sends a third state change instruction to the data node; the third state change instruction is for the data node to change the second previous state to the idle state; wherein the other previous state is a previous state of the M previous states other than the first previous state and the second previous state;

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

5. The method of claim 4, further comprising:

when the M previous states are 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 the data node to change the third front state into the pre-preparation working state;

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

6. The method of claim 4, further comprising:

any service node in the M service nodes receives a target instruction; the target instruction is used for instructing the any service node to update the previous state of the 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 the data node to update the previous state of any service node in the data node;

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

7. The method of claim 4, further comprising:

under the condition that any service node in 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 value,

any service node sends a control node updating 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 newly 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 death state or the pre-preparation working state, and a first previous state represents that the process of the target service is in the working state, the first service node is configured to send a first state change instruction to the data node; the first state change instruction is used for instructing 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 recorded by the data node latest, in the first service node;

the data node is configured to update the first previous state to a state representing that the process of the target service is 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 a second previous state is the pre-preparation working state, the current control node is the second service node, and a previous state except the second previous state among the M previous states is 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 among the M service nodes in the data node; the heartbeat timestamp 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 heartbeat timestamp is later than a time for the second service node to read 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 configured to run the process of the target service to process the target service when determining that the pre-second state is the working state.

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

10. A computer program product, comprising a computer program which, when run, causes a computer to perform the single-instance process switching method of any of claims 1 to 7.

Images