CN109725950B - Method, device and storage medium for realizing single-instance operation of client - Google Patents
Method, device and storage medium for realizing single-instance operation of client Download PDFInfo
- Publication number
- CN109725950B CN109725950B CN201811633993.0A CN201811633993A CN109725950B CN 109725950 B CN109725950 B CN 109725950B CN 201811633993 A CN201811633993 A CN 201811633993A CN 109725950 B CN109725950 B CN 109725950B
- Authority
- CN
- China
- Prior art keywords
- client
- local
- server object
- local server
- started
- 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
- 238000000034 method Methods 0.000 title claims abstract description 87
- 230000008569 process Effects 0.000 claims abstract description 55
- 230000006870 function Effects 0.000 claims description 30
- 238000004590 computer program Methods 0.000 claims description 13
- 238000012790 confirmation Methods 0.000 claims description 3
- 238000004891 communication Methods 0.000 description 18
- 238000010586 diagram Methods 0.000 description 5
- 238000012545 processing Methods 0.000 description 5
- 230000008878 coupling Effects 0.000 description 3
- 238000010168 coupling process Methods 0.000 description 3
- 238000005859 coupling reaction Methods 0.000 description 3
- 230000007717 exclusion Effects 0.000 description 3
- 238000006243 chemical reaction Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 241000251468 Actinopterygii Species 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 239000000470 constituent Substances 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 238000012544 monitoring process Methods 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Images
Landscapes
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
- Information Transfer Between Computers (AREA)
Abstract
The invention discloses a method, a device and a storage medium for realizing single-instance operation of a client, which are suitable for the technical field of application starting. The method provided by the invention comprises the following steps: after a preset client is started for the first time, locking a local file corresponding to the preset client, and creating a local server object; when the preset client is monitored to be started again, after the current start is confirmed to be the second start, sending a message to the local server object, and exiting the current start process; and after receiving the message, the local server object displays a main program window on a system interface. The method and the device not only realize the single-instance operation started by the client, reduce the access error caused by data confusion, save system resources, but also facilitate the acquisition and the opening of the window started for the first time, and improve the user experience.
Description
Technical Field
The invention belongs to the technical field of application starting, and particularly relates to a method, a device and a storage medium for realizing single-instance operation of a client.
Background
When an application program is started, a system creates a starting process to execute application starting tasks, and particularly manages the starting process by creating an instance. The system creates an instance each time a client is opened, and multiple openings of the client may cause data conflicts resulting in lost or erroneous access to the data.
In order to ensure that the client side has only one single instance when starting the whole, at present, a common method is to use a mutual exclusion lock to realize the single instance running of the starting process, the mutual exclusion lock can realize that the application starting process is accessed by only one instance object, but when starting for the second time, the opened client side program cannot be displayed, and the user experience is influenced.
Disclosure of Invention
In view of this, embodiments of the present invention provide a method, an apparatus, and a storage medium for implementing single-instance operation of a client, so as to implement single-instance operation of the client and ensure that an opened client can be displayed during secondary startup. .
In a first aspect of the embodiments of the present invention, a method for implementing single-instance operation of a client is provided, including:
after a preset client is started for the first time, locking a local file corresponding to the preset client, and creating a local server object;
when the preset client is monitored to be started again, after the current start is confirmed to be the second start, sending a message to the local server object, and exiting the current start process;
and after receiving the message, the local server object displays a main program window on a system interface.
In a second aspect of the embodiments of the present invention, there is provided an apparatus for implementing client list instance operation, including:
the locking module is used for locking a local file corresponding to a preset client after the preset client is started for the first time and creating a local server object;
the confirming module is used for sending a message to the local server object and quitting the current starting process after the preset client is monitored to be started again and the current starting is confirmed to be the second starting;
and the display module is used for displaying the main program window on a system interface after the local server object receives the message.
In a third aspect of the embodiments of the present invention, there is provided an apparatus, including a memory, a processor, and a computer program stored in the memory and executable on the processor, where the processor executes the computer program to implement the steps of the method according to the first aspect of the embodiments of the present invention.
In a fourth aspect of the embodiments of the present invention, a computer-readable storage medium is provided, in which a computer program is stored, and the computer program, when executed by a processor, implements the steps of the method provided in the first aspect of the embodiments of the present invention.
In a fifth aspect of embodiments of the present invention, a computer program product is provided, the computer program product comprising a computer program that, when executed by one or more processors, performs the steps of the method provided in the first aspect of embodiments of the present invention.
In the embodiment of the invention, the file lock is added to the client terminal during the first starting, the local server is created, when the client terminal is started for the second time, the current starting thread is quitted after the current starting is confirmed to be the second starting, and the main window during the first starting is called and displayed through communication with the local server. Therefore, single-instance operation of client starting is realized, the window started for the first time is conveniently acquired and opened under the condition of the same function as the mutually exclusive lockset, not only is system resources saved, but also access errors caused by data confusion can be reduced, and user experience is improved.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings needed to be used in the embodiments or the prior art descriptions will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without inventive exercise.
Fig. 1 is a flowchart of an embodiment of a method for implementing single-instance operation of a client according to an embodiment of the present invention;
fig. 2 is a flowchart of another embodiment of a method for implementing single-instance operation of a client according to an embodiment of the present invention;
fig. 3 is a schematic structural diagram of an apparatus for implementing single-instance operation of a client according to an embodiment of the present invention;
fig. 4 is a schematic structural diagram of a terminal device according to an embodiment of the present invention.
Detailed Description
The embodiment of the invention provides a method, a device and a storage medium for realizing single-instance operation of a client, which are used for realizing that only one single instance is operated in the whole situation of the client and conveniently calling an opened client window.
In order to make the objects, features and advantages of the present invention more obvious and understandable, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention, and it is obvious that the embodiments described below are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
The first embodiment is as follows:
referring to fig. 1, a flow diagram of a method for calling a singleton interface according to an embodiment of the present invention includes the following steps:
s101, after a preset client is started for the first time, locking a local file corresponding to the preset client, and creating a local server object;
the predetermined client refers to an application program installed on the user equipment, such as a fish fighting APP client. The starting refers to a process that a user opens an application program by clicking an exe executable file or a desktop shortcut start icon. When an application is started, a series of tasks are executed, such as data initialization, obtaining a running environment, connecting a network to initiate a network request, and the like, and the application starting process can be generally managed by creating a single instance.
After the local file corresponding to the preset client is installed on the client, the local file is stored in an application file on a system hard disk, the local files comprise configuration files, plug-ins, executable files and the like, and the locking operation is to add file locks to the local files, so that the local files can only be accessed by the current program, namely the current single instance.
The local server, that is, a server created locally, may be used for process communication, for example, a server based on a local socket (socket) implemented by a QLocalServer, and the QLocalServer is used for creating the local server and may receive a connection from the local socket. The local server object is used for processing communication messages with the client.
Optionally, a local file name and a current process session ID corresponding to the predetermined client are obtained, and the local file name and the current process session ID are spliced to serve as the unique ID of the predetermined client.
Further, the file lock of the local server object and the local file is identified by the predetermined client unique ID, and a Listen function is invoked to Listen to the predetermined client unique ID.
S102, when the preset client is monitored to be started again, after the current start is confirmed to be the second start, sending a message to the local server object, and exiting the current start process;
the restart means that the client is started again when the client is still in the running process after the first start. The client side can create an instance management starting process every time the client side is started, the client side is frequently started, the access data are prone to be disordered, the client side is prevented from being repeatedly started only through the mutual exclusion lock, the client side can not be subjected to any reaction when the client side is opened for the second time after a user is minimized to a tray, when the user is in a tray, the client side to be opened is difficult to find, when the application programs in the tray of the system are too many, the client side is directly started, no reaction is generated, and therefore the user use experience can be directly influenced.
The current single-instance starting process firstly accesses a local file to judge whether the local file is added with a file lock or not, when the fact that the local file cannot be loaded is found, whether the current starting is the second starting or not is confirmed, and since a client possibly exits from an operation state after being started each time, the current starting state needs to be confirmed, specifically, a local file handle corresponding to the preset client is obtained, and whether the local file handle is locked or not is judged; and when the local file handle is not locked, confirming that the current start is the second start. The file handle is used to uniquely identify a local file, and may be represented by the predetermined client unique ID.
And S103, after receiving the message, the local server object displays a main program window on a system interface.
The current starting is confirmed to be secondary starting by communicating with the local server object, the current starting process is exited, and the local server object can control the display of the main program window after successfully receiving the message.
The main program window is the current display window of the client after the client is started for the first time. The currently launched process may notify the presentation of the main window by communicating with the process of the local server.
Optionally, a local connection object is created, the local connection object calls a connectToServer function to connect to the local server object, and after the connection is successful, a predetermined message is sent to the local server object. The predetermined message may be a message for verifying whether the communication is successful, or may be a message for performing a predetermined operation, such as calling back a client host interface.
In the steps, the single-instance operation of the client is ensured by locking the local file of the client, the starting process is quitted after the current secondary starting is confirmed, the data access error caused by starting the client for multiple times is prevented, and the process communication is realized by establishing the local server, so that a user can call and display the main window after the first starting when the secondary starting is carried out.
Example two:
on the basis of fig. 1, a detailed method and a detailed process for implementing the single-instance operation of the client are described in detail with reference to fig. 2, as follows:
s201, creating a local file lock of a client;
before creating a file lock for a local file, a unique ID of the client needs to be set first for identifying the client.
Illustratively, in a client initialization interface, an applicationfile path function is called to obtain a local file name of the client, the function can obtain a file name under a local file path of the client, and a ProcessIdToSessionId function is called to obtain a fixed ID string, the function can obtain a session ID under a current process, the local file name and the ID string of the client are spliced as a unique ID of the predetermined client, and the unique ID is used as a local file name corresponding to a local server name and a file lock and is used for uniquely identifying the local file lock and the local server, so that malicious modification of a subsequent process is prevented.
And creating a QtLockedFile object which is mainly used for controlling the starting of single instances of a plurality of clients. In the object, a setFileName function is called to set the unique ID of the client obtained in the first step as a local file name;
in the object, an open function is called to open a local file handle of the client, and then a lock function is called to remove the file handle and lock. Therefore, the current locked file can only be accessed by the current single instance, and the single instance of the client started for the second time can not acquire the access authority of the local file handle.
And defining and calling an isLock function in the QtLockedFile object, and judging whether the file handle of the client is locked before restarting so as to determine whether the current starting is the second starting.
By calling a file locking method defined in the QtLockedFile object and judging whether the file is locked or not, the local file of the client terminal started for the first time can be locked, and meanwhile, whether the file is started for the first time or not can be judged. Specifically, each time the client is started, the isLock function is called to determine whether the client is started twice. Since it is possible to exit the client after each start of the client, i.e. the travel is finished, it is first necessary to confirm the current client start status.
S202, creating a local server;
the local server can be a virtual server in communication of two processes in programming, such as a local server commonly used in Socket.
Before creating the local server, the client is preferably confirmed to be started for the first time.
If the current starting is the first starting, besides the lock locking is called, a QLocalServer local server object is created, and a list function is called to monitor the unique ID of the client. The QLocalServer object is used for communicating with the starting process opened for the second time.
S203, confirming that the starting is carried out for the second time, and exiting the current starting process;
the application executes the starting process through the single instance, and then runs the state after the starting is finished. In the embodiment of the invention, when the method is applied to the automatic process, whether the current starting is the secondary starting or not is preferentially judged.
If the client is started for the second time, a sendMessage function is called to send a message to the client started for the first time, and then return is called to exit the current starting process.
Optionally, before sending the message, the method further includes: a qlocalcocket local connection object is created and then the connectToServer function is called to connect to the local server object created in S202. The qlocalcocket object may communicate with the first time the client is opened.
And S204, communicating with a local server, and calling and displaying a main program window.
The starting process of the client can realize message transmission among processes by establishing communication. In order to ensure the single-instance operation of the client, the communication between the starting processes can confirm that the current process is the secondary starting, and can transmit parameters, so that the calling display of a main program window can be realized when the secondary starting is carried out, and the main program window can be the display window of the client when the client is started for the first time.
Based on the communication connection in step S203, the local server receives the message sent by the second start process, which indicates that the current communication is successful, and calls an activateWindow function to display the main program window of the client through the communication connection, where the activateWindow function may set the main program window as a top-layer window to display the opened client window interface.
In the embodiment of the invention, the communication mechanism between the clients is started twice based on the clients, so that not only can the single-instance operation of the clients be ensured, but also the opened client windows can be displayed.
It should be understood that, the sequence numbers of the steps in the foregoing embodiments do not imply an execution sequence, and the execution sequence of each process should be determined by its function and inherent logic, and should not constitute any limitation to the implementation process of the embodiments of the present invention.
Example three:
the foregoing mainly describes a method for implementing client-side single-instance operation, and a device for implementing client-side single-instance operation is described in detail below.
Fig. 3 shows a schematic structural diagram of an apparatus for implementing client single-instance operation, including:
the locking module 310 is configured to, after a predetermined client is started for the first time, perform a locking operation on a local file corresponding to the predetermined client, and create a local server object;
after the local file corresponding to the preset client is installed on the client, the local file is stored in an application file on a system hard disk, the local files comprise configuration files, plug-ins, executable files and the like, and the locking operation is to add file locks to the local files, so that the local files can only be accessed by the current program, namely the current single instance.
The local server, i.e., a server created locally, may be used for process communication, such as a local socket (socket) based server implemented by QtLocalServer. The local server object is used for processing communication messages with the client.
Optionally, after the predetermined client is started for the first time, performing a locking operation on the local file corresponding to the client, and creating a local server object further includes:
and acquiring a local file name and a current process session ID corresponding to the preset client, and splicing the local file name and the current process session ID as the unique ID of the preset client.
Optionally, the file lock of the local server object and the local file is identified by using the predetermined client unique ID, and a Listen function is invoked to monitor the predetermined client unique ID.
A confirming module 320, configured to send a message to the local server object and exit from a current starting process after it is monitored that the predetermined client is restarted and it is confirmed that the current starting is the second starting;
optionally, the confirming module 320 includes:
the judging unit is used for acquiring a local file handle corresponding to the preset client and judging whether the local file handle is locked or not;
and the confirming unit is used for confirming that the current start is the second start when the local file handle is not locked.
And the display module 330 is configured to display the main program window on a system interface after the local server object receives the message.
Optionally, the sending the message to the local server object specifically includes:
and creating a local connection object, calling a connectToServer function to connect the local server object by the local connection object, and sending a predetermined message to the local server object after the connection is successful.
The device can ensure the single instance running started by the client through the locking module and the confirmation module, saves system resources, prevents the access data from being confused and making mistakes, realizes process communication and is convenient to display the opened client.
Example four:
fig. 4 is a schematic diagram of a device structure for implementing single-instance operation of a client according to an embodiment of the present invention. The apparatus may generally be a terminal device, i.e. a mobile computer device with a touch screen, including but not limited to a smart phone, a smart watch, a notebook, a tablet, a POS machine, and even a vehicle-mounted computer. As shown in fig. 4, the terminal apparatus 4 of this embodiment includes: a memory 410, a processor 420, and a system bus 430, the memory 410 including executable programs 4101 stored thereon, it being understood by those skilled in the art that the terminal device structure shown in fig. 4 does not constitute a limitation of a server, and may include more or fewer components than shown, or some components in combination, or a different arrangement of components.
The following specifically describes each constituent component of the terminal apparatus with reference to fig. 4:
the memory 410 may be used to store software programs and modules, and the processor 420 performs various functional applications of the terminal and data processing by operating the software programs and modules stored in the memory 410. The memory 410 may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required by at least one function (such as a sound playing function, an image playing function, etc.), and the like; the storage data area may store data (such as audio data, a phonebook, etc.) created according to the use of the server, and the like. Further, the memory 410 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.
On the memory 410 is embodied an executable program 4101 of a network request method, said executable program 4101 may be divided into one or more modules/units, which are stored in said memory 410 and executed by the processor 420 to implement single instance execution of a client, said one or more modules/units may be a series of computer program instruction segments capable of performing specific functions, which are used to describe the execution process of said computer program 4101 in said server 4. For example, the computer program 4101 may be divided into a locking module, a confirmation module, and a display module.
The processor 420 is a control center of the server, connects various parts of the entire terminal device using various interfaces and lines, performs various functions of the terminal and processes data by operating or executing software programs and/or modules stored in the memory 410 and calling data stored in the memory 410, thereby integrally monitoring the terminal. Alternatively, processor 420 may include one or more processing units; preferably, the processor 420 may integrate an application processor, which mainly handles operating systems, application programs, etc., and a modem processor, which mainly handles wireless communications. It will be appreciated that the modem processor described above may not be integrated into processor 420.
The system bus 430 is used to connect functional units inside the computer, and can transmit data information, address information, and control information, and may be, for example, a PCI bus, an ISA bus, a VESA bus, etc. The instructions of the processor 420 are transmitted to the memory 410 through the bus, the memory 410 feeds data back to the processor 420, and the system bus 430 is responsible for data and instruction interaction between the processor 420 and the memory 410. Of course, the system bus 430 may also access other devices such as network interfaces, display devices, and the like.
The terminal device at least comprises a network card, an output device and the like, and other components are not described in detail herein.
In this embodiment of the present invention, the executable program executed by the processor 420 included in the terminal device specifically includes:
a method for realizing single-instance operation of a client comprises the following steps:
after a preset client is started for the first time, locking a local file corresponding to the preset client, and creating a local server object;
when the preset client is monitored to be started again, after the current start is confirmed to be the second start, sending a message to the local server object, and exiting the current start process;
and after receiving the message, the local server object displays a main program window on a system interface.
Further, after the predetermined client is started for the first time, performing a locking operation on the local file corresponding to the client, and creating a local server object further includes:
and acquiring a local file name and a current process session ID corresponding to the preset client, and splicing the local file name and the current process session ID as the unique ID of the preset client.
Further, the splicing the local file name and the current process session ID as the predetermined client unique ID further includes:
and identifying the file lock of the local server object and the local file by using the predetermined client unique ID, and calling a Listen function to monitor the predetermined client unique ID.
Further, the determining that the current start is the second start specifically includes:
acquiring a local file handle corresponding to the preset client, and judging whether the local file handle is locked or not;
and when the local file handle is not locked, confirming that the current start is the second start.
Further, the sending the message to the local server object specifically includes:
and creating a local connection object, calling a connectToServer function to connect the local server object by the local connection object, and sending a predetermined message to the local server object after the connection is successful.
It is clear to those skilled in the art that, for convenience and brevity of description, the specific working processes of the above-described systems, apparatuses and units may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.
In the above embodiments, the descriptions of the respective embodiments have respective emphasis, and reference may be made to the related descriptions of other embodiments for parts that are not described or illustrated in a certain embodiment.
Those of ordinary skill in the art would appreciate that the modules, elements, and/or method steps of the various embodiments described in connection with the embodiments disclosed herein may be implemented as electronic hardware, or combinations of computer software and electronic hardware. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the implementation. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.
In the several embodiments provided in the present application, it should be understood that the disclosed system, apparatus and method may be implemented in other manners. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the units is only one logical division, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.
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, may be located in one place, or may be 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, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, and can also be realized in a form of a software functional unit.
The above-mentioned embodiments are only used for illustrating the technical solutions of the present invention, and not for limiting the same; although the present invention has been described in detail with reference to the foregoing embodiments, it will be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some technical features may be equivalently replaced; and such modifications or substitutions do not depart from the spirit and scope of the corresponding technical solutions of the embodiments of the present invention.
Claims (8)
1. A method for realizing single-instance operation of a client is characterized by comprising the following steps:
after a preset client is started for the first time, locking a local file corresponding to the preset client, and creating a local server object;
when the preset client is monitored to be started again, after the current start is confirmed to be the second start, sending a message to the local server object, and exiting the current start process; wherein, the determination that the current start is the second start is specifically as follows: acquiring a local file handle corresponding to the preset client, and judging whether the local file handle is locked or not; when the local file handle is not locked, the current start is confirmed to be the second start;
and after receiving the message, the local server object displays a first started main program window on a system interface.
2. The method of claim 1, wherein after the predetermined client is started for the first time, locking a local file corresponding to the client, and creating a local server object further comprises:
and acquiring a local file name and a current process session ID corresponding to the preset client, and splicing the local file name and the current process session ID as the unique ID of the preset client.
3. The method of claim 2, wherein said concatenating the local filename and the current process session ID as the predetermined client unique ID further comprises:
and identifying the file lock of the local server object and the local file by using the predetermined client unique ID, and calling a Listen function to monitor the predetermined client unique ID.
4. The method according to claim 1, wherein the sending of the message to the local server object specifically comprises:
and creating a local connection object, calling a connectToServer function to connect the local server object by the local connection object, and sending a predetermined message to the local server object after the connection is successful.
5. An apparatus for implementing client-side single-instance operation, comprising:
the locking module is used for locking a local file corresponding to a preset client after the preset client is started for the first time and creating a local server object;
the confirming module is used for sending a message to the local server object and quitting the current starting process after the preset client is monitored to be started again and the current starting is confirmed to be the second starting; wherein the confirmation module comprises: the judging unit is used for acquiring a local file handle corresponding to the preset client and judging whether the local file handle is locked or not; the confirming unit is used for confirming that the current starting is the second starting when the local file handle is not locked;
and the display module is used for displaying the first started main program window on a system interface after the local server object receives the message.
6. The apparatus according to claim 5, wherein the sending of the message to the local server object is specifically:
and creating a local connection object, calling a connectToServer function to connect the local server object by the local connection object, and sending a predetermined message to the local server object after the connection is successful.
7. A terminal device comprising a memory, a processor and a computer program stored in the memory and executable on the processor, wherein the processor implements the steps of the method of implementing client single-instance operation as claimed in any one of claims 1 to 4 when executing the computer program.
8. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the steps of the method of carrying out client single-instance execution as claimed in any one of claims 1 to 4.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811633993.0A CN109725950B (en) | 2018-12-29 | 2018-12-29 | Method, device and storage medium for realizing single-instance operation of client |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811633993.0A CN109725950B (en) | 2018-12-29 | 2018-12-29 | Method, device and storage medium for realizing single-instance operation of client |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109725950A CN109725950A (en) | 2019-05-07 |
| CN109725950B true CN109725950B (en) | 2022-02-22 |
Family
ID=66297880
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201811633993.0A Active CN109725950B (en) | 2018-12-29 | 2018-12-29 | Method, device and storage medium for realizing single-instance operation of client |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109725950B (en) |
Families Citing this family (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112130932B (en) * | 2020-09-29 | 2023-10-27 | 珠海海鸟科技有限公司 | Single-instance operation method and device and electronic equipment |
| CN112416555B (en) * | 2020-11-20 | 2022-09-23 | 山东亚华电子股份有限公司 | Client restarting method, device and apparatus, and storage medium |
| CN114816159A (en) * | 2021-01-27 | 2022-07-29 | 武汉斗鱼网络科技有限公司 | Application icon adding method and device, electronic equipment and storage medium |
| CN113110895B (en) * | 2021-03-19 | 2024-07-09 | 深圳震有科技股份有限公司 | IPC-based method, terminal and storage medium for setting single instance application program |
| CN113110889B (en) * | 2021-04-16 | 2023-12-05 | 北京沃东天骏信息技术有限公司 | Global message prompting method, global message prompting device, medium and electronic equipment |
| CN113448651B (en) * | 2021-08-31 | 2021-12-14 | 北京鲸鲮信息系统技术有限公司 | Method and device for realizing application singleton function |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102200941A (en) * | 2010-03-25 | 2011-09-28 | 杭州华三通信技术有限公司 | Method and unit for monitoring process state |
| CN102025728A (en) * | 2010-11-26 | 2011-04-20 | 中兴通讯股份有限公司 | Scheduling method under client-side/server-side architecture and server |
| CN105574437B (en) * | 2015-12-31 | 2019-03-19 | 北京金山安全软件有限公司 | Method and device for protecting privacy information and electronic equipment |
-
2018
- 2018-12-29 CN CN201811633993.0A patent/CN109725950B/en active Active
Also Published As
| Publication number | Publication date |
|---|---|
| CN109725950A (en) | 2019-05-07 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109725950B (en) | Method, device and storage medium for realizing single-instance operation of client | |
| CN106844137B (en) | Server monitoring method and device | |
| CN108536519B (en) | Method for automatically building Kubernetes main node and terminal equipment | |
| US9253265B2 (en) | Hot pluggable extensions for access management system | |
| US9483281B2 (en) | Methods, systems, and computer readable mediums for updating components in a converged infrastructure system | |
| US10127031B2 (en) | Method for updating a program on a communication apparatus | |
| CN109308241B (en) | Method and device for monitoring starting process of application program, terminal equipment and storage medium | |
| US11106453B2 (en) | Method and system for a client to server deployment via an online distribution platform | |
| CN108681777B (en) | Method and device for running machine learning program based on distributed system | |
| CN111865629B (en) | Method, apparatus and computer program product for configuring service instances | |
| US20150149909A1 (en) | Communication apparatus, communication method, and recording medium | |
| US10795747B2 (en) | File synchronizing service status monitoring and error handling | |
| CN104360952B (en) | A kind of software testing system and method | |
| US20160231997A1 (en) | Communication apparatus, communication system, communication method, and recording medium | |
| CN110381042B (en) | Graceful restart service method, device, medium and electronic equipment | |
| US10404568B2 (en) | Agent manager for distributed transaction monitoring system | |
| CN113220433B (en) | Agent program operation management method and system | |
| CN110968331A (en) | Method and apparatus for running an application | |
| US11425203B2 (en) | Commissioning a virtualized network function | |
| CN108563472B (en) | Method and device for loading service plug-in based on multi-open application | |
| CN113885971A (en) | State management method and device based on self-adaptive platform system | |
| CN111615171B (en) | Access method and device of wireless local area network | |
| FR3003365A1 (en) | METHOD AND DEVICE FOR MANAGING SOFTWARE UPDATES OF A SET OF EQUIPMENT OF A SYSTEM SUCH AS A SYSTEM OF AN AIRCRAFT | |
| CN115665265B (en) | Request processing method, device, equipment, storage medium and system | |
| CN115309457A (en) | Application instance restarting method and device, electronic equipment and readable storage medium |
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 | ||
| TR01 | Transfer of patent right | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20240220 Address after: Room 311, No. 13 Tangxia Heguang Sanheng Road, Tianhe District, Guangzhou City, Guangdong Province, 510000 Patentee after: Guangzhou Diandian Electronic Technology Co.,Ltd. Country or region after: China Address before: 430000 East Lake Development Zone, Wuhan City, Hubei Province, No. 1 Software Park East Road 4.1 Phase B1 Building 11 Building Patentee before: WUHAN DOUYU NETWORK TECHNOLOGY Co.,Ltd. Country or region before: China |