CN109660583B - Information processing method and device, equipment and storage medium - Google Patents
Information processing method and device, equipment and storage medium Download PDFInfo
- Publication number
- CN109660583B CN109660583B CN201710948085.XA CN201710948085A CN109660583B CN 109660583 B CN109660583 B CN 109660583B CN 201710948085 A CN201710948085 A CN 201710948085A CN 109660583 B CN109660583 B CN 109660583B
- Authority
- CN
- China
- Prior art keywords
- data
- version information
- buffer window
- terminal
- synchronization
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/01—Protocols
- H04L67/10—Protocols in which an application is distributed across nodes in the network
- H04L67/1095—Replication or mirroring of data, e.g. scheduling or transport for data synchronisation between network nodes
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/50—Network services
- H04L67/56—Provisioning of proxy services
- H04L67/568—Storing data temporarily at an intermediate stage, e.g. caching
Landscapes
- Engineering & Computer Science (AREA)
- Computer Networks & Wireless Communication (AREA)
- Signal Processing (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The invention discloses an information processing method, an information processing device, information processing equipment and a storage medium, wherein the method comprises the following steps: determining first version information of synchronous data on a terminal; determining second version information of the synchronous data on the server; when the second version information is inconsistent with the first version information, determining that the first incremental data corresponding to the second version information is updated from the first version information; when the first incremental data is in a preset data buffer window, acquiring the first incremental data from the data buffer window; and synchronizing the first incremental data and the second version information to the terminal.
Description
Technical Field
The present invention relates to electronic technologies, and in particular, to an information processing method and apparatus, a device, and a storage medium.
Background
In order to increase the number of loaded players, the network game server is usually split into a plurality of service processes according to functions. Different processes are responsible for different play functions and data storage. Different play modules are closely related, and the play of one process often depends on data in other play processes. While most network games place a great emphasis on the real-time nature of player interaction, the processing delay of a player's request must be less than the sensory reaction time, otherwise it results in a stuck game experience. This requires the computational logic of the play and the dependent data to be in the same process, avoiding the additional request processing delay added to cross-process data queries. Therefore, it is desirable to synchronize data of one process to other processes that depend on the data. Each process maintains data cache of the dependent data, and only the data cache in the process needs to be queried when querying the data.
The data synchronization process is simply abstracted, and two roles exist in the process. And the data source is mainly responsible for the progress of the play module. One is a subscriber and mainly depends on other processes of the data of the play module. The subscriber subscribes to the data of the data source, and the data is synchronized to the subscriber when the data of the data source changes. To ensure the correctness of game play, the data in the data source and the subscriber needs to be consistent. But data may be lost during transmission due to network fluctuations. In addition, the process where the subscriber is located may need to be restarted online due to hardware or software failure, and since the data cache does not perform persistent storage, the cache data is lost after restarting. An interprocess data synchronization scheme needs to solve the above-mentioned problems.
Disclosure of Invention
In view of the above, embodiments of the present invention provide an information processing method, an information processing apparatus, a device, and a storage medium to solve at least one problem in the prior art, which can efficiently perform data synchronization.
The technical scheme of the embodiment of the invention is realized as follows:
the embodiment of the invention provides an information processing method, which comprises the following steps:
determining first version information of synchronous data on a terminal;
determining second version information of the synchronous data on the server;
when the second version information is inconsistent with the first version information, determining that the first incremental data corresponding to the second version information is updated from the first version information;
when the first incremental data is in a preset data buffer window, acquiring the first incremental data from the data buffer window;
and synchronizing the first incremental data and the second version information to the terminal.
An embodiment of the present invention provides an information processing apparatus, which includes a first determining unit, a second determining unit, a third determining unit, an obtaining unit, and a first synchronizing unit, wherein:
the first determining unit is used for determining first version information of the synchronous data on the terminal;
the second determining unit is used for determining second version information of the synchronous data on the server;
the third determining unit is configured to determine, when the second version information is inconsistent with the first version information, first incremental data corresponding to updating from the first version information to the second version information;
the acquiring unit is used for acquiring the first incremental data from a preset data buffer window when the first incremental data is in the data buffer window;
and the first synchronization unit is used for synchronizing the first incremental data and the second version information to a terminal.
An embodiment of the present invention provides a computer device, which includes a memory, a processor, and a computer program stored in the memory and executable on the processor, where the processor implements the steps of the information processing method when executing the program.
An embodiment of the present invention provides a computer-readable storage medium, on which a computer program is stored, which, when executed by a processor, implements the steps of the information processing method described above.
In the embodiment of the invention, first version information of synchronous data on a terminal is determined; determining second version information of the synchronous data on the server; when the second version information is inconsistent with the first version information, determining that the first incremental data corresponding to the second version information is updated from the first version information; when the first incremental data is in a preset data buffer window, acquiring the first incremental data from the data buffer window; synchronizing the first incremental data and the second version information to a terminal; in this way, data synchronization can be performed efficiently through the data buffer window.
Drawings
FIG. 1-1 is a schematic flow chart of an implementation of an information processing method according to an embodiment of the present invention;
FIG. 1-2 is a schematic flow chart of an implementation of an information processing method according to an embodiment of the present invention;
FIGS. 1-3 are schematic diagrams of system architectures according to embodiments of the present invention;
FIG. 2 is a diagram of a generic interprocess data synchronization framework according to an embodiment of the present invention;
FIG. 3 is a diagram of a data synchronization framework according to an embodiment of the present invention;
FIG. 4 is a schematic diagram of a data synchronization method based on version numbers and windows according to an embodiment of the present invention;
FIG. 5-1 is a schematic flow chart of an implementation of the information processing method according to the embodiment of the present invention;
FIG. 5-2 is a schematic flow chart of an implementation of the information processing method according to the embodiment of the present invention;
5-3 are schematic diagrams of the implementation flows of the information processing method according to the embodiment of the present invention;
FIG. 6 is a schematic structural diagram of an information processing apparatus according to an embodiment of the present invention;
fig. 7 is a schematic diagram of a hardware entity of a computing device according to an embodiment of the present invention.
Detailed Description
The data synchronization process in this embodiment is divided into two modes, one is a snapshot synchronization mode, and the other is a command synchronization mode. The snapshot data in the snapshot synchronization mode is the full data of the module at a certain moment, so the full data is synchronized when the snapshot synchronization mode is adopted; the command data of the command synchronization mode is incremental data modification in the module, and the incremental data is synchronized when the command synchronization mode is adopted. And during initialization, the data source and the subscriber are consistent in a snapshot synchronization mode, and the data modification command is forwarded to the subscriber when the data modification is carried out on the subsequent data source. Commands may be lost during transmission, and in order to maintain data consistency between the data source and the subscriber, the data source performs snapshot synchronization periodically.
Fig. 1-1 is a schematic flow chart of an implementation of a data synchronization method according to an embodiment of the present invention, as shown in fig. 1-1, the method includes:
step S101, a subscriber configures a data source;
step S102, a subscriber sends a connection request to a data source;
step S103, the data source sends a connection response to the subscriber;
step S104, a subscriber sends a synchronization request to a data source;
step S105, a data source initializes snapshot synchronization;
step S106, the data source sends snapshot data to the subscriber;
step S107, a subscriber loads snapshot data;
step S108, the data source modifies the data;
step S109, the data source forwards the command data to the subscriber;
step S110, the subscriber orders to redo;
step S111, synchronizing the data source timing snapshots;
step S112, the data source sends snapshot data to the subscriber;
in step S113, the subscriber loads snapshot data.
As can be seen from the above flow, the problem with the data synchronization scheme is how to set the timing interval duration of the snapshot synchronization. If the timing interval is long, then during two snapshot synchronizations, the loss of data during the synchronization process may result in a long time window where the data source and the subscriber data do not coincide, thereby affecting the accuracy of the gaming function. If the timing interval is short, the data source needs to frequently synchronize the full amount of data. The data source needs to resynchronize the snapshot data even if no data loss occurs during two snapshot synchronizations, or if only a small portion of the data is lost. The generation and synchronization of snapshot data is relatively time-consuming operation, and may affect the business function of the process itself. This is inefficient.
For a better understanding of the various embodiments of the invention, an explanation of the following terms is provided:
network game: also known as online games, generally refer to electronic games in which multiple players play interactive entertainment over a computer network.
The network game client side: the program is a program corresponding to the network game server and providing local service for the client. The system is generally installed on a common user machine and needs to be matched with a server side to operate.
The network game server: the network game client-side is a software program which corresponds to the network game client-side, is installed in the IDC and provides data forwarding and logic processing services for the network game client-side. In network games, complex and critical logic requires computation on the network game server, since clients installed on player machines are easily cracked and used for cheating.
Network delay: network latency refers to the time required for a message or packet to travel from one end of a network to another. In the network game, the request is sent from the client to the reply returned by the server received by the client.
And (3) data consistency guarantee: under the condition that the data has multiple copies, if the network, the server hardware or the software fails, the partial copy writing is successful, and the partial copy writing fails. This results in data inconsistency and data content conflicts between the copies. In practice, it is desirable to provide consistency guarantees for data between multiple copies.
Because different playing methods of the network game are mutually dependent, different processes of the server have a data synchronization process, but the conventional data synchronization scheme has the problems of inconsistent data or low synchronization efficiency and the like. In each embodiment of the invention, data synchronization is carried out based on the data version number and the command buffer window, and the data consistency of the interprocess data in the synchronization process can be effectively ensured by combining the snapshot synchronization and the command synchronization.
The technical solution of the present invention is further elaborated below with reference to the drawings and the specific embodiments.
The embodiment of the invention provides an information processing method, which is applied to computing equipment, wherein the functions realized by the method can be realized by calling a program code through a processor in the computing equipment, and the program code can be saved in a computer storage medium.
Fig. 1-2 are schematic diagrams illustrating an implementation flow of an information processing method according to an embodiment of the present invention, as shown in fig. 1-2, the method includes:
step S121, the server determines first version information of the synchronous data on the terminal;
here, the version information of the sync data may be represented by a version number; the terminal may be various types of devices with information processing capability in the implementation process, for example, the terminal may include a mobile phone, a tablet computer, a desktop computer, a personal digital assistant, a television, and the like.
Here, the determining the first version information of the synchronization data on the terminal includes: the server receives a data synchronization request initiated by the terminal, analyzes the data synchronization request, and obtains the first version information, wherein the data synchronization request carries the first version information of the synchronization data on the terminal, and the initiated data synchronization request at least comprises one of the following: the terminal and the server initiate a data synchronization request when reconnecting; the terminal receives the synchronous data sent by the server and then sends a data synchronization request when detecting that the data is lost; and the terminal periodically initiates a data synchronization request.
Step S122, the server determines second version information of the synchronous data on the server;
here, the present embodiment provides a system architecture, referring to fig. 1-3, which shows a system 2 for managing clients and servers 22 of various Application programs (APP), such as game applications, on a terminal 21. The number of the terminals 21 and the server 22 may be plural. The system 2 includes one or more client-installed terminals 21 and one or more servers 22, and these terminals 21 and servers 22 are connected via a network 23. The terminal 21 has installed therein a client that can perform or manage various applications. The client may be a network game installed in the terminal 21. One player at least corresponds to one player, and the terminals have data synchronization requirements. The server in this embodiment may be understood as a data source, and each terminal may be understood as a subscriber.
Step S123, when the second version information is inconsistent with the first version information, the server determines that the first version information is updated to the first incremental data corresponding to the second version information;
step S124, when the first incremental data is in a preset data buffer window, the server acquires the first incremental data from the data buffer window;
here, the second version information of the server side is generally higher than or equal to the first version information, and the first version information is unlikely to be higher than the second version information, if the first version information is not equal to or lower than the second version information, the server determines to update the first incremental data corresponding to the second version information from the first version information, and if the second version information is 102 and the first version information is 100, and if the version information is a continuous integer, the first incremental data corresponding to the update from the version information 100 to 102 includes data volumes corresponding to the two versions of the version information 101 and 102.
Step S125, the server synchronizes the first incremental data and the second version information to the terminal.
Here, the server synchronizes the first incremental data and the second version information to the terminal, which is actually a command synchronization method, and the terminal updates its own synchronization data and updates its own version information to the second version information according to the received first incremental data and the received second version information.
In other embodiments, the data buffer window is a consistency guarantee mechanism provided by this embodiment, as shown in fig. 1-2, the server 21 maintains the data buffer window, where the data buffer window is a first-in first-out queue, and maintains some latest modification commands. Whenever the server 21 receives a data modification, it first adds the data version information, inserts the command data into the command buffer window, and then synchronizes the command to all terminals 22. The terminal 22 updates the current data version information after receiving and executing the command. After the server 21 and the terminal 22 maintain the version information, it can judge whether the command is lost in the synchronization process by comparing the version information difference between the two.
In another embodiment, in step S123, the method further includes:
step S11, when the first incremental data is not in the data buffer window and the full data corresponding to the second version information is in the data buffer window, the server synchronizes the full data corresponding to the second version information and the second version information to the terminal;
here, N incremental data with continuous version information are cached in the data buffer window, N is an integer greater than or equal to 2, M full-size data are cached in the data buffer window, and M is an integer greater than or equal to 1;
step S12, when the full amount of data corresponding to the second version information is not in the data buffer window, the server generates the full amount of data corresponding to the second version information;
and step S13, the server synchronizes the full data corresponding to the second version information and the second version information to the terminal.
Here, the server in step S11 and step S13 is actually a snapshot synchronization method for synchronizing the full amount of data corresponding to the second version information and the second version information to the terminal, and the terminal updates its own synchronization data according to the received full amount of data corresponding to the second version information and the second version information, and updates its own version information to the second version information.
Step S14, the server caches the full amount of data corresponding to the second version information in the data buffer window.
Here, when the terminal is disconnected from the server, if the disconnection time is too long, the version information of the terminal is not in the data buffer window, and then the server needs to resynchronize to generate the snapshot. In an actual operation environment, a plurality of server processes are deployed on a single physical machine, and if a hardware failure occurs, the server processes may be affected by a plurality of processes on the same physical machine. When the failure recovery needs resynchronization, a situation that a plurality of processes simultaneously initiate a synchronization request and a snapshot needs to be generated may occur, which may affect a service function and cause a stuck experience. The solution to this problem is that when the first terminal needs to generate a snapshot, the server records the version number corresponding to the snapshot and caches the snapshot. When other terminals need to take the snapshot in the following process, the server firstly checks whether a cache snapshot exists or not, and if the cache snapshot exists, the version corresponding to the snapshot is still in the command buffer window; the terminal can be returned to the latest data state by using the cached snapshot and the command data after the snapshot version number, so that the situation that the snapshot needs to be generated repeatedly in a short time is avoided.
In other embodiments, N pieces of incremental data with consecutive version information are cached in the data buffer window, where N is an integer greater than or equal to 2, and determining that the first incremental data is in the preset data buffer window includes:
step S21, determining initial version information in the data buffer window;
step S22, when the initial version information is less than or equal to the next version information of the first version information, determining that the first incremental data is in a preset data buffer window;
here, assuming that the first version information is 105 and the second version information is 200, as in step S528 of fig. 5-2, the initial version information in the data buffer window is 101 and the final version information is 200. If the version information is an integer number, the next version information of the first version information is 106, the initial version information is 101, and the initial version information 101 < the next version information 106 of the first version information indicates that the first incremental data corresponding to the update from the first version information 105 to the second version information 200 is in the data buffer window, see step S528 in fig. 5-2, and the first incremental data is in the data buffer window.
Step S23, when the initial version information is higher than the next version information of the first version information, determining that the first incremental data is not in a preset data buffer window.
Here, assuming that the first version information is 99 and the second version information is 200, as in step S528 of fig. 5-2, the initial version information in the data buffer window is 101 and the final version information is 200. If the version information is an integer number, then the next version information of the first version information is 100, then the initial version information is 101, and the initial version information 101 is greater than the next version information 100 of the first version information, which means that the first incremental data corresponding to the update from the first version information 99 to the second version information 200 is not in the data buffer window, see step S528 in fig. 5-2, and the first incremental data is not in the data buffer window.
In other embodiments, the method further comprises:
step S31, the server receives the synchronous data sent by other terminals synchronous with the terminal;
step S32, the server caches the synchronous data in the data buffer window, and takes the next version information of the second version information as the third version information;
step S33, the server determines the third version information as the version information of the synchronization data;
step S34, the server sends the third version information and the synchronization data corresponding to the third version information to the terminal.
In other embodiments, the method further comprises:
step S41, the server determines the fourth version information of the synchronous data on other terminals synchronous with the terminal;
step S42, when the second version information is inconsistent with the fourth version information, the server determines that the second incremental data corresponding to the second version information is updated from the fourth version information;
step S43, judging whether the second incremental data is in a preset data buffer window, if so, going to step S44, and if not, going to step S45;
step S44, when the second incremental data is in a preset data buffer window, acquiring the second incremental data in the data buffer window, and then synchronizing the second incremental data and the second version information to a terminal;
here, step S44 is similar to step S104 and step S105 in fig. 1-2, and can be understood by those skilled in the art with reference to step S104 and step S105;
step S45, when the second incremental data is not in the preset data buffer window, determining whether the full data corresponding to the second version information is in the data buffer window, if so, going to step S46, and if not, going to step S47;
step S46, the server obtains the full amount of data corresponding to the second version information from the data buffer window when the full amount of data corresponding to the second version information is in the data buffer window; and then, the server synchronizes the full data corresponding to the second version information and the second version information to the terminal.
Step S47, the full amount of data corresponding to the second version information is not in the data buffer window, the full amount of data corresponding to the second version information is generated, and then the full amount of data corresponding to the second version information and the second version information are synchronized to the terminal.
It can be seen from the above description that, when data at the terminal side is missing, the incremental synchronization is performed first because the incremental synchronization data amount is small, and if corresponding incremental data exists in the data buffer window, the incremental data is obtained from the data buffer window first, so that the incremental data is prevented from being repeatedly generated, and further the efficiency is improved; if the corresponding incremental data does not exist in the data buffer window, full-scale synchronization is carried out, and if the corresponding full-scale data exists in the data buffer window, the full-scale data is obtained from the data buffer window, so that repeated generation of the full-scale data is avoided, and further the efficiency is improved; and if the data buffer window does not have corresponding full data, generating the full data by adopting a snapshot mode, and then synchronizing the full data to the terminal.
The embodiment of the present invention provides a general inter-process data synchronization framework, as shown in fig. 2, the data synchronization framework includes data sources 21 and subscribers 22, where the data sources 21 may include one or more data sources, and the number of the subscribers 22 is at least two. If the data source 21 determines that snapshot data is to be generated, the data source 21 retrieves the service data from the service database 23, and then the data source 21 sends the retrieved service data to the subscriber 22 as snapshot data 24, and the subscriber caches the snapshot data sent by the data source so as to update the subscriber's terminal or use the cached data in the process of interacting with other subscribers. If the data source 21 determines that command data is to be generated, the data source 21 retrieves incremental business data from the business database, and then the data source sends the retrieved incremental business data to the subscriber 21 as command data 25 (i.e., incremental data), and the subscriber caches the incremental data sent by the data source to update the subscriber's terminal or to use the cached data in the course of interaction with other subscribers.
From the above, it can be seen that the interactive process between the data source and the subscriber only needs to provide the snapshot, the command and the loading interface, and notify the subscriber when the data is modified, so that the data source can provide the consistency guarantee for the data synchronization process, and the data source and the subscriber do not need to pay attention to the details of the synchronization process. Therefore, the technical scheme provided by the embodiment of the invention is simple in process and easy to realize.
As shown in FIG. 3, the data synchronization framework provided by the embodiment of the present invention provides data consistency guarantees 32 for data sources and subscribers from the aspects of command detection 321, disconnection reconnect 322, and snapshot multiplexing 323. The consistency guarantee between the data source 21 and the subscriber 22 is achieved through a data buffer window 31, and command synchronization (2) and snapshot synchronization (3) are performed based on the data buffer window, wherein the data synchronization framework is applicable to two scenarios, namely, a general command detection and disconnection reconnection scenario. The data buffer window 31 may include a command buffer window and a snapshot buffer window during implementation, wherein the command buffer window is used for implementing buffering of incremental data, and the snapshot buffer window is used for implementing buffering of full data, so as to implement snapshot multiplexing based on the snapshot buffer window. The subscriber can send a synchronization request (1) to the data source, and after the data source receives the synchronization request, the data source can reply a synchronization response to the subscriber through a snapshot synchronization mode (3) and a command synchronization mode (2).
In the data synchronization framework provided by the embodiment of the invention, the data source and the subscriber respectively maintain respective data version numbers, and the version numbers are generated by the data source in a self-increment mode when the data source receives data modification. The data source also maintains a command buffer window, which is a first-in-first-out queue that maintains the most recent modified commands. Whenever a data source receives a data modification, the data version number is incremented, the command data is inserted into the command buffer window, and the command is then synchronized to all subscribers. And after receiving and executing the command, the subscriber updates the current data version number. After the data source and the subscriber maintain the version numbers, whether the command is lost in the synchronization process can be judged by comparing the difference of the version numbers of the data source and the subscriber.
As shown in FIG. 4, the data source also maintains a command buffer window 41, where the command buffer window 41 is a first-in-first-out queue that maintains the most recent modified commands. Whenever a data source receives a data modification, it first increments the data version number, assuming the version number is 100, inserts command data, i.e., delta data, into a command buffer window (S42), and then broadcasts a modification command (S43), i.e., synchronizes the command to all subscribers, i.e., subscribers 1 to 3. After receiving and executing the command, the subscriber updates the current data version number, i.e. the subscriber updates the version number to the version number 100. After the data source and the subscriber maintain the version numbers, whether the command is lost in the synchronization process can be judged by comparing the difference of the version numbers of the data source and the subscriber.
Fig. 5-1 is a schematic flow chart of an implementation of the information processing method according to the embodiment of the present invention, as shown in fig. 5-1, the method includes:
step S501, data modification is carried out on a data source;
here, the data source modifies its version number to 100 and modifies the command buffer window. For convenience of understanding, it is assumed in this embodiment that the command buffer window can buffer 100 data blocks, and there are 100 version numbers corresponding to the initial version number and the last version number. It should be noted that, in practice, the storage space of the command buffer window may be a certain amount, the number of data that can be cached by the command buffer window depends on the size of the data block, if the data block is large, the number of cached data blocks is small, and if the data block is small, the number of cached data blocks is large.
Step S502, a data source forwards a command;
here, the command corresponds to version 100 and to the delta data.
Step S503, after receiving the command forwarded by the data source, the subscriber receives the incremental data in the command, caches the incremental data, and stores the version number 100 of the incremental data. In the embodiment shown in fig. 5-1, 100 in parentheses, i.e., (100), is the version number.
Step S504, the data source modifies the data;
here, the data source modifies its version number to 101 and modifies the command buffer window. This step is similar to the aforementioned step S501, and reference can be made to the aforementioned step S501.
Step S505, forwarding a command by a data source;
here, the command corresponds to version 101 and corresponding delta data.
In step S506, due to a network or the like, the subscriber cannot receive the command forwarded by the data source, and therefore the version information of the data stored on the subscriber side is still 100.
Step S507, the data source modifies the data;
here, the data source modifies its version number to 102 and modifies the command buffer window.
Step S508, the data source forwards the order;
here, the command corresponds to version 102 and to the delta data.
In step S509, the version number of the subscriber side is not continuously lost.
Step S510, the data source may also send a command for timing the version number to the subscriber;
here, the subscriber may perform passive detection and active detection to find out whether the version number on the side of the subscriber is continuous. Step S510 is an implementation manner of step S509, after the data source sends a command of timing the version number to the subscriber, the subscriber responds to the command to perform detection.
Step S511, the subscriber reports the version number of the subscriber to the data source;
here, the subscriber reports its version number to the data source as 100.
Step S512, a data source detects a command buffer window;
here, the data source discovers that both data versions 101 and 102 missing from the subscriber are in the command buffer window, and thus, the data source can data synchronize the subscriber in incremental data.
Step S513, the data source sends a complementary missing command to the subscriber;
here, the complement miss command carries version information 101 and 102 and corresponding synchronization data.
Step S514, the subscriber redos the data according to the loss supplementing command, and synchronizes the data to the version number 102.
As can be seen from the embodiment shown in fig. 5-1, the command of version number 101 is lost during synchronization and the subscriber's version number stays at 100. The data source subsequently receives the data modification and synchronizes the command to the subscriber. The subscriber finds that the current version number is 100, but receives a command of version number 102, the version number is not continuous, which means that the intermediate command data is lost during synchronization. This is a process of triggering passive detection through subsequent data modification, and if there is no data modification for a long time, there is also an active detection mode, i.e. the data source will synchronize the latest version number to the subscriber to trigger detection. After detecting data loss, the subscriber reports the current version number to the data source, and after receiving the report of the version number, the data source firstly checks the command buffer window to see whether the command data after the subscriber version number is still in the buffer window. If still in the buffer window, the data source will take the command data missing from the subscriber from the window and send it to the subscriber. If the command data after the subscriber version number is not in the window at this time, the data source needs to regenerate the data snapshot and send the data snapshot to the subscriber.
Fig. 5-2 is a schematic flow chart of an implementation of the information processing method according to the embodiment of the present invention, and as shown in fig. 5-2, the method includes:
step S521, modifying data by the data source;
here, the data source modifies its version number to 105 and modifies the command buffer window.
Step S522, the data source forwards the command;
here, the command corresponds to version 105 and corresponding delta data.
Step S523, after receiving the command forwarded by the data source, the subscriber receives the incremental data in the command, caches the incremental data, and stores the version number 105 of the incremental data.
Step S524, the connection between the data source and the subscriber fails;
step S525, subscriber connection overtime tries reconnection;
step S526, after a period of time, the subscriber is successfully connected with the data source again;
step S527, a subscriber sends a synchronization request to a data source;
here, the synchronization request carries the subscriber's own version number 105.
Step S528, the data source detects a command buffer window;
here, the data source finds itself with a version number of 200 and finds that both the data versions 106 and 200 missing by the subscriber are in the command buffer window, so the data source can data synchronize the subscriber in incremental data.
Step S529, the data source sends a complementary missing command to the subscriber;
here, the complement miss command carries version information 106 and 200 and corresponding synchronization data.
Step S530, the subscriber redos the missing command according to the reissue command, and synchronizes its own data to the version number 102.
FIG. 5-1 illustrates what is said to be the case of individual command loss, and FIG. 5-2 illustrates that the connection between the data source and the subscriber is broken when the duration of the failure time is long. The data source and the subscriber maintain the connection status through heartbeat. When the connection fails, the subscriber attempts a reconnection when the subscriber heartbeat detection times out. If the failover reconnection is successful, the subscriber initiates a data synchronization request and carries the current data version number. After the data source receives the synchronization request, the same procedure as before for recovering the lost command is performed. Whether to reissue the data through buffered command data or regenerate a data snapshot will also be determined based on whether the subscriber's current version number is in the buffer window. This is more efficient as it avoids the need to regenerate snapshots when commands lost during a line break are still in the window.
Fig. 5-3 is a schematic flow chart of an implementation of the information processing method according to the embodiment of the present invention, and as shown in fig. 5-3, the method includes:
step S541, subscriber 1 sends a synchronization request to the data source;
step S542, the data source regenerates the snapshot, caches the snapshot and records the corresponding version number;
step S543, the data source is synchronized to the subscriber 1 in a snapshot mode;
step S544, the subscriber 2 sends a synchronization request to the data source;
step S545, the data source finds that the data cache window has cached snapshot data, and the version number is in the window;
step S546, the data source sends a cache command to the subscriber 2;
in step S547, the data source sends the snapshot data to subscriber 2.
In the embodiment shown in fig. 5-3, if the outage lasts too long and the subscriber version number is not already in the buffer window, a resynchronization to generate a snapshot is required. In an actual operation environment, a plurality of server processes are deployed on a single physical machine, and if a hardware failure occurs, the server processes may be affected by a plurality of processes on the same physical machine. When the failure recovery needs resynchronization, a situation that a plurality of processes simultaneously initiate a synchronization request and a snapshot needs to be generated may occur, which may affect a service function and cause a stuck experience. The solution to this problem is that when the first subscriber needs to generate a snapshot, the data source records the version number corresponding to the snapshot and caches the snapshot. When other subscribers need the snapshot in the following period, the data source first checks whether there is a cached snapshot, and if there is a cached snapshot and the version corresponding to the snapshot is still in the command buffer window. The cached snapshot and the command data after the snapshot version number can be used to bring the subscriber back to the latest data state, thus avoiding the situation that the snapshot needs to be generated repeatedly in a short time.
It should be noted that, in the above embodiment, the subscriber receives the data synchronization commands strictly according to the sequence of the version numbers, and directly discards the commands out of sequence, and the data source reissues the command data after the current version number of the subscriber. In other embodiments, the subscriber caches non-sequential commands first, and reports the version number interval of the subscriber missing command to the data source, and the data source reissues the missing command data.
It can be seen from the foregoing technical solutions that the embodiments of the present invention provide a solution for providing consistency guarantee for data synchronization between processes, and when only a small portion of data is lost during transmission, data can be recovered efficiently.
The embodiment of the invention provides an information processing device, and each part of the device can be realized by a processor in computing equipment; the functions implemented by the processor may also be implemented by a logic circuit, and in the implementation process, the processor may be a Central Processing Unit (CPU), a Microprocessor (MPU), a Digital Signal Processor (DSP), a Field Programmable Gate Array (FPGA), or the like. As illustrated in fig. 6, the apparatus in the embodiment of the present invention includes:
fig. 6 is a schematic structural diagram of an information processing apparatus according to an embodiment of the present invention, and as shown in fig. 6, the apparatus 600 includes a first determining unit 601, a second determining unit 602, a third determining unit 603, an obtaining unit 604, and a first synchronizing unit 605, where:
the first determining unit 601 is configured to determine first version information of synchronization data on a terminal;
the second determining unit 602 is configured to determine second version information of the synchronization data on the server;
the third determining unit 603 is configured to determine, when the second version information is inconsistent with the first version information, first incremental data corresponding to updating from the first version information to the second version information;
the obtaining unit 604 is configured to obtain the first incremental data from a preset data buffer window when the first incremental data is in the data buffer window;
the first synchronization unit 605 is configured to synchronize the first incremental data and the second version information to the terminal.
In other embodiments, M pieces of full-size data are cached in the data buffer window, where M is an integer greater than or equal to 1, and the apparatus further includes a second synchronization unit, configured to synchronize, to a terminal, the full-size data corresponding to the second version information and the second version information when the first incremental data is not in the data buffer window and the full-size data corresponding to the second version information is in the data buffer window.
In other embodiments, the apparatus further comprises a generating unit and a third synchronizing unit, wherein:
the generating unit is configured to generate full data corresponding to the second version information when the full data corresponding to the second version information is not in the data buffer window;
and the third synchronization unit is used for synchronizing the full data corresponding to the second version information and the second version information to the terminal.
In other embodiments, the apparatus further includes a first caching unit, configured to cache a full amount of data corresponding to the second version information in the data buffering window.
In other embodiments, N pieces of incremental data with consecutive version information are cached in the data buffer window, where N is an integer greater than or equal to 2, and the apparatus further includes a fourth determining unit configured to: determining initial version information in the data buffer window; when the initial version information is less than or equal to the next version information of the first version information, determining that the first incremental data is in a preset data buffer window; when the initial version information is higher than the next version information of the first version information, determining that the first incremental data is not in a preset data buffer window.
In other embodiments, the apparatus further comprises a receiving unit, a second buffering unit, and a fifth determining unit, wherein:
the receiving unit is used for receiving synchronous data sent by other terminals which are synchronous with the terminal;
the second cache unit is configured to cache the synchronous data in the data buffer window;
the fifth determining unit is configured to determine, as third version information, the next version information of the second version information, and the third version information as the version information of the synchronization data.
In other embodiments, the apparatus further includes a fourth synchronization unit configured to synchronize the third version information and synchronization data corresponding to the third version information to the terminal.
In other embodiments, the first determining unit is configured to receive a data synchronization request initiated by the terminal, where the data synchronization request carries first version information of synchronization data on the terminal, and the initiated data synchronization request at least includes one of:
the terminal and the server initiate a data synchronization request when reconnecting;
the terminal receives the synchronous data sent by the server and then sends a data synchronization request when detecting that the data is lost;
and the terminal periodically initiates a data synchronization request.
In other embodiments, the apparatus further comprises a sixth determining unit, a seventh determining unit, a second obtaining unit, and a fifth synchronizing unit, wherein:
the sixth determining unit is configured to determine fourth version information of the synchronization data on the other terminal that is synchronized with the terminal;
the seventh determining unit is configured to determine, when the second version information is inconsistent with the fourth version information, second incremental data corresponding to updating from the fourth version information to the second version information;
the second obtaining unit is configured to obtain, when the second incremental data is not in a preset data buffer window and the full data corresponding to the second version information is in the data buffer window, the full data corresponding to the second version information from the data buffer window;
and the fifth synchronization unit is used for synchronizing the full data corresponding to the second version information and the second version information to the terminal.
Here, it should be noted that: the above description of the apparatus embodiments, similar to the above description of the method embodiments, has similar beneficial effects as the method embodiments. For technical details not disclosed in the embodiments of the apparatus according to the invention, reference is made to the description of the embodiments of the method according to the invention for understanding.
In the embodiment of the present invention, if the information processing method is implemented in the form of a software functional part and sold or used as an independent product, the information processing method may be stored in a computer-readable storage medium. Based on such understanding, the technical solutions of the embodiments of the present invention may be essentially implemented or a part contributing to the prior art may be embodied in the form of a software product, which is stored in a storage medium and includes several instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the methods described in the embodiments of the present invention. And the aforementioned storage medium includes: various media capable of storing program codes, such as a usb disk, a removable hard disk, a Read Only Memory (ROM), a magnetic disk, or an optical disk. Thus, embodiments of the invention are not limited to any specific combination of hardware and software.
Correspondingly, the embodiment of the present invention further provides a computer-readable storage medium, on which a computer program is stored, and the computer program, when executed by a processor, implements the steps of the information processing method described above.
Correspondingly, the embodiment of the present invention further provides a computer device, which includes a memory, a processor, and a computer program stored in the memory and executable on the processor, and when the processor executes the computer program, the steps of the information processing method described above are implemented.
In the embodiment of the present invention, the server may be implemented by a server cluster or a computer, such as a personal computer. Fig. 7 is a schematic diagram of a hardware entity of a computing device in an embodiment of the present invention, where the hardware entity of the computing device 700 includes: a processor 701, a communication interface 702, an input module 703, a display module 704 and a memory 705, wherein
The processor 701 generally controls the overall operation of the computing device 700. For example, the input module 703 may be implemented as a touch screen, and output user operation data representing operation characteristics (including a touch point position, a touch point number, and a trigger pressure) of the touch screen to the processor 701, and the processor 701 may parse the user operation data to determine a function triggered by a user in the display interface, and generate display data corresponding to the triggered function, so that the display module 704 loads a page corresponding to the triggered function.
The communication interface 702 may enable the computing device to communicate with other terminals or servers over a network.
The input module 703 may be configured to receive input character information and generate signal inputs related to user settings and function controls. The input module may include a touch surface, which may collect a touch operation by a user (e.g., a user's operation on or near the touch surface using a finger, a stylus, or any other suitable object or attachment), acquire a signal from the touch operation, convert the signal into touch coordinates, send the touch coordinates to the processor 701 for processing, and receive and execute a command from the processor 701.
The display module 704 may be configured to display the functions performed by the processor 701 and related information.
The Memory 705 is configured to store instructions and applications executable by the processor 701, and may also cache data (e.g., image data, audio data, voice communication data, and video communication data) to be processed or already processed by the processor 701 and modules in the computing device 700, and may be implemented by a FLASH Memory (FLASH) or a Random Access Memory 705 (RAM).
It should be appreciated that reference throughout this specification to "one embodiment" or "an embodiment" means that a particular feature, structure or characteristic described in connection with the embodiment is included in at least one embodiment of the present invention. Thus, the appearances of the phrases "in one embodiment" or "in an embodiment" in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. It should be understood that, in various embodiments of the present invention, the sequence numbers of the above-mentioned processes do not mean the execution sequence, and the execution sequence of each process should be determined by its function and inherent logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention. The above-mentioned serial numbers of the embodiments of the present invention are merely for description and do not represent the merits of the embodiments.
It should be noted that, in this document, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.
In the several embodiments provided in the present application, it should be understood that the disclosed apparatus and method may be implemented in other ways. The above-described device embodiments are merely illustrative, for example, the division of the unit is only a logical functional division, and there may be other division ways in actual implementation, such as: multiple units or components may be combined, or may be integrated into another system, or some features may be omitted, or not implemented. In addition, the coupling, direct coupling or communication connection between the components shown or discussed may be through some interfaces, and the indirect coupling or communication connection between the devices or units may be electrical, mechanical or other forms.
The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units; can be located in one place or distributed on a plurality of network units; some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment. In addition, all the functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may be separately regarded as one unit, or two or more units may be integrated into one unit; the integrated unit can be realized in a form of hardware, or in a form of hardware plus a software functional unit.
Those of ordinary skill in the art will understand that: all or part of the steps for realizing the method embodiments can be completed by hardware related to program instructions, the program can be stored in a computer readable storage medium, and the program executes the steps comprising the method embodiments when executed; and the aforementioned storage medium includes: various media that can store program codes, such as a removable Memory device, a Read Only Memory (ROM), a magnetic disk, or an optical disk.
Alternatively, the integrated unit of the present invention may be stored in a computer-readable storage medium if it is implemented in the form of a software functional module and sold or used as a separate product. Based on such understanding, the technical solutions of the embodiments of the present invention may be essentially implemented or a part contributing to the prior art may be embodied in the form of a software product, which is stored in a storage medium and includes several instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the methods described in the embodiments of the present invention. And the aforementioned storage medium includes: a removable storage device, a ROM, a magnetic or optical disk, or other various media that can store program code.
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 appended claims.
Claims (12)
1. An information processing method, characterized in that the method comprises:
determining first version information of synchronous data on a terminal;
determining second version information of the synchronous data on the server;
when the full data corresponding to the second version information is inconsistent with the full data corresponding to the first version information, determining to update the first incremental data corresponding to the second version information from the first version information;
determining initial version information of a data cache window, wherein the data cache window comprises a command buffer window and a snapshot buffer window, the command buffer window is used for realizing the buffering of incremental data, and the snapshot buffer window is used for realizing the buffering of full data;
when the first incremental data is determined to be in the command buffer window based on the initial version information and the next version information of the first version information, acquiring the first incremental data from the command buffer window; synchronizing the first incremental data and the second version information to the terminal in a command synchronization mode;
and when it is determined that the first incremental data is not in the command buffer window and the full data corresponding to the second version information is in the snapshot buffer window based on the initial version information and the next version information of the first version information, synchronizing the full data corresponding to the second version information and the second version information to the terminal in a snapshot synchronization manner.
2. The method of claim 1, further comprising:
when the full data corresponding to the second version information is not in the snapshot buffer window, generating the full data corresponding to the second version information;
and synchronizing the full data corresponding to the second version information and the second version information to the terminal.
3. The method of claim 2, further comprising:
and caching the full data corresponding to the second version information in the snapshot buffer window.
4. The method according to any one of claims 1 to 3, wherein incremental data with continuous version information is buffered in the data buffer window, and the method further comprises:
when the initial version information is less than or equal to the next version information of the first version information, determining that the first incremental data is in the preset data buffer window;
when the initial version information is higher than the next version information of the first version information, determining that the first incremental data is not in the preset data buffer window.
5. The method according to any one of claims 1 to 3, further comprising:
receiving synchronous data sent by other terminals synchronous with the terminal;
caching the synchronous data in the data buffering window, and taking the next version information of the second version information as third version information;
determining the third version information as version information of the synchronization data.
6. The method of claim 5, further comprising:
and sending the third version information and the synchronous data corresponding to the third version information to the terminal.
7. The method according to any of claims 1 to 3, wherein the determining the first version information of the synchronization data on the terminal comprises:
receiving a data synchronization request initiated by the terminal, where the data synchronization request carries first version information of synchronization data on the terminal, and the initiated data synchronization request at least includes one of the following:
the terminal and the server initiate a data synchronization request when reconnecting;
the terminal receives the synchronous data sent by the server and then sends a data synchronization request when detecting that the data is lost;
and the terminal periodically initiates a data synchronization request.
8. The method according to any one of claims 1 to 3, further comprising:
determining fourth version information of the synchronous data on other terminals which are synchronous with the terminal;
when the second version information is inconsistent with the fourth version information, determining that the fourth version information is updated to second incremental data corresponding to the second version information;
when the second incremental data is not in a preset data buffer window and the full data corresponding to the second version information is in the data buffer window, acquiring the full data corresponding to the second version information from the data buffer window;
and synchronizing the full data corresponding to the second version information and the second version information to the terminal.
9. An information processing apparatus characterized by comprising a first determining unit, a second determining unit, a third determining unit, an acquiring unit, and a first synchronizing unit, wherein:
the first determining unit is used for determining first version information of the synchronous data on the terminal;
the second determining unit is used for determining second version information of the synchronous data on the server;
the third determining unit is configured to determine to update the first incremental data corresponding to the second version information from the first version information when the full amount of data corresponding to the second version information is inconsistent with the full amount of data corresponding to the first version information;
the acquiring unit is configured to determine initial version information of a data cache window, where the data cache window includes a command buffer window and a snapshot buffer window, the command buffer window is used to implement buffering of incremental data, and the snapshot buffer window is used to implement buffering of full data;
the obtaining unit is further configured to obtain the first incremental data from the command buffer window when it is determined that the first incremental data is in the command buffer window based on the initial version information and next version information of the first version information;
the first synchronization unit is used for synchronizing the first incremental data and the second version information to a terminal in a command synchronization mode;
the first synchronization unit is further configured to synchronize, when it is determined based on the initial version information and the next version information of the first version information that the first incremental data is not in the command buffer window and the full data corresponding to the second version information is in the snapshot buffer window, the full data corresponding to the second version information and the second version information to the terminal in a snapshot synchronization manner.
10. The apparatus of claim 9, further comprising a generating unit and a third synchronizing unit, wherein:
the generating unit is configured to generate full data corresponding to the second version information when the full data corresponding to the second version information is not in the snapshot buffer window;
and the third synchronization unit is used for synchronizing the full data corresponding to the second version information and the second version information to the terminal.
11. A computer device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the steps of the information processing method according to any of the preceding claims 1 to 8 are implemented when the program is executed by the processor.
12. A computer-readable storage medium, on which a computer program is stored, characterized in that the computer program, when being executed by a processor, carries out the steps of the information processing method of any one of the preceding claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710948085.XA CN109660583B (en) | 2017-10-12 | 2017-10-12 | Information processing method and device, equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201710948085.XA CN109660583B (en) | 2017-10-12 | 2017-10-12 | Information processing method and device, equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109660583A CN109660583A (en) | 2019-04-19 |
| CN109660583B true CN109660583B (en) | 2021-09-07 |
Family
ID=66108954
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201710948085.XA Active CN109660583B (en) | 2017-10-12 | 2017-10-12 | Information processing method and device, equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109660583B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112199383A (en) * | 2020-10-19 | 2021-01-08 | 珠海金山网络游戏科技有限公司 | Data updating method and device |
| CN113885780A (en) * | 2021-02-10 | 2022-01-04 | 京东科技控股股份有限公司 | Data synchronization method, device, electronic equipment, system and storage medium |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101102219A (en) * | 2007-07-30 | 2008-01-09 | 华为技术有限公司 | Software update system and software update method |
| CN102164302A (en) * | 2011-03-11 | 2011-08-24 | 青岛海信传媒网络技术有限公司 | Presenting server and data operation method thereof |
| CN104881494A (en) * | 2015-06-12 | 2015-09-02 | 北京奇虎科技有限公司 | Method, device and system for performing data synchronization with Redis server |
| CN107193575A (en) * | 2016-03-15 | 2017-09-22 | 日本冲信息株式会社 | Information processor, information processing system and information processing method |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US9892000B2 (en) * | 2014-08-29 | 2018-02-13 | Dropbox, Inc. | Undo changes on a client device |
-
2017
- 2017-10-12 CN CN201710948085.XA patent/CN109660583B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101102219A (en) * | 2007-07-30 | 2008-01-09 | 华为技术有限公司 | Software update system and software update method |
| CN102164302A (en) * | 2011-03-11 | 2011-08-24 | 青岛海信传媒网络技术有限公司 | Presenting server and data operation method thereof |
| CN104881494A (en) * | 2015-06-12 | 2015-09-02 | 北京奇虎科技有限公司 | Method, device and system for performing data synchronization with Redis server |
| CN107193575A (en) * | 2016-03-15 | 2017-09-22 | 日本冲信息株式会社 | Information processor, information processing system and information processing method |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109660583A (en) | 2019-04-19 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10455014B2 (en) | Method and apparatus for synchronizing content | |
| US9367554B1 (en) | Systems and methods for enhancing performance of a clustered source code management system | |
| US9411869B2 (en) | Replication between sites using keys associated with modified data | |
| CN111368002A (en) | Data processing method, system, computer equipment and storage medium | |
| CN109660583B (en) | Information processing method and device, equipment and storage medium | |
| CN112367149B (en) | Message acquisition method, device, equipment and storage medium | |
| CN111669438B (en) | Live broadcast message transmission method and device, electronic equipment and medium | |
| US20190356897A1 (en) | Correlation of video stream frame timestamps based on a system clock | |
| CN108200219A (en) | Method of data synchronization, device, server and storage medium | |
| EP2615758A1 (en) | Fault-tolerant method for online game interaction logic and fault-tolerant system and client for online games | |
| WO2018000692A1 (en) | Data synchronization method and system, user terminal and server for data synchronization | |
| CN106897288B (en) | Service providing method and system for database | |
| EP4270299A1 (en) | Operating system upgrade method, electronic device, and storage medium | |
| CN109821235B (en) | Game video recording method, device and server | |
| CN113032160B (en) | Data synchronization management method and related device | |
| WO2024087914A1 (en) | Data synchronization method and computing device | |
| KR102117180B1 (en) | Image drawing methods, related devices and systems | |
| US9686320B2 (en) | Crisscross cancellation protocol | |
| CN109603153B (en) | Virtual event processing method and device, electronic equipment and storage medium | |
| CN109688176B (en) | File synchronization method, terminal, network device and storage medium | |
| CN112749172A (en) | Data synchronization method and system between cache and database | |
| CN112138372B (en) | Data synchronization method in distributed system and related equipment | |
| US7007028B2 (en) | Smart poller for optical network management systems | |
| JP5552368B2 (en) | Thin client terminal, buffering control program | |
| JP6043687B2 (en) | Server / client system |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |