CN115525464A - A system, method and storage medium for dealing with application program crash - Google Patents

Abstract

The application discloses a system, a method and a storage medium for coping with application program crash, wherein the system comprises: the crash signal acquisition module is used for acquiring a crash signal of the application program; the crash exception processing module is coupled with the crash signal acquisition module and used for closing the main program according to the crash signal and outputting a restart signal; and the restarting module is coupled with the crash exception handling module and is used for restarting the main program according to the restarting signal. The crash exception processing module is used for guiding the closing of the main program according to the crash signal, so that a system is prevented from generating an error report frame, and the steps of manual operation are reduced; the main program is restarted after the main program is confirmed to be completely closed through the restarting module, so that the application program is restarted, the problem of improper operation is avoided, the time for closing the main program and restarting the process is comprehensively realized, the idle time in the process can be reduced, and the restarting speed after the main program is broken down is effectively improved.

Description

A system, method and storage medium for dealing with application program crash

technical field

The invention relates to the technical field of electronic equipment, in particular to a system, method and storage medium for dealing with application program crashes.

Background technique

With the development of the Internet, various applications have emerged. In order to meet the needs of users, applications with different functions have been continuously developed, which greatly facilitates the life and work of users. At the same time, it also causes users Situations that require the use of a large number of applications.

At present, in order to improve user experience, applications are required to run uninterrupted. However, based on various reasons such as hardware, software, or improper operation, applications often crash probabilistically, and applications will crash after crashes. An error report box pops up to prevent the crashed application process from exiting. Only when the user closes the error report box manually, the crashed application process will be closed. That is to say, after the application program crashes, it is necessary to manually process the error report box to close the application process.

Therefore, in the prior art, after the application program crashes, it is necessary to manually process the error report box to close the application program, which leads to the problem that the restart speed of the main program after the crash is slow.

Contents of the invention

In view of this, it is necessary to provide a system, method and storage medium for dealing with application program crashes, which are used to solve the problem in the prior art that the application program needs to be manually processed to close the application program after the application program crashes.

In order to solve the above problems, the present invention provides a system for dealing with application program crashes, including:

The crash signal acquisition module is used to acquire the crash signal of the application program;

The crash exception processing module is coupled with the crash signal acquisition module, and is used to close the main program according to the crash signal and output a restart signal;

The restart module, coupled with the crash exception handling module, is used to restart the main program according to the restart signal.

Further, the crash signal acquisition module includes a waiting unit, which is used to acquire the crash signal of the application program according to the running status of the main program.

Further, the crash exception processing module includes a crash exception processing unit and a state judgment unit, wherein the crash exception processing unit is used to close the main program according to the crash signal, and the state judgment unit is used to output a restart signal according to the opening and closing state of the main program.

Further, the restart module includes creating a process unit for starting the main program according to the restart signal.

In order to solve the above problems, the present invention also provides a method for dealing with application program crashes, including:

Get the crash signal of the application;

Close the main program according to the crash signal and output a restart signal;

Restart the main program according to the restart signal.

Further, obtain the crash signal of the application, including:

Set the waiting function, and obtain the running status of the main program according to the waiting function;

According to the running state of the main program, it is judged whether to output the crash signal of the application program;

When the running state of the main program is crash and exit, output the crash signal of the application program; when the running state of the main program is running normally, keep the current running state.

Further, close the main program according to the crash signal and output a restart signal, including:

Set crash exception handling function and state discrimination function;

The crash exception handling function outputs an instruction to close the main program according to the crash signal;

The state discrimination function judges whether to output the restart signal according to the opening and closing state of the main program;

When the opening and closing state of the main program is closed, the restart signal is output; when the opening and closing state of the main program is open, the current running state is maintained.

Further, the crash exception handling function is set based on the SetUnhandledExceptionFilter function.

Further, restart the main program according to the restart signal, including:

A restart function is set, and an instruction to restart the main program is output according to the restart signal.

In order to solve the above problems, the present invention also provides a computer-readable storage medium, in which a computer program is stored, wherein, when the computer program is running, the device where the computer-readable storage medium is located is controlled to perform the above-mentioned processing App crash method.

The beneficial effects of adopting the above technical solution are: the present invention provides a system, method and storage medium for dealing with application program crashes, the system includes: a crash signal acquisition module for acquiring application program crash signals; a crash exception processing module, and The crash signal acquisition module is coupled to close the main program according to the crash signal and output a restart signal; the restart module is coupled to the crash exception processing module and is used to restart the main program according to the restart signal. The crash exception processing module guides the shutdown of the main program according to the crash signal, thereby avoiding the system from generating an error report box and reducing the steps of manual operations; the restart module restarts the main program after confirming that the main program is completely closed, so as to restart the application program, not only The problem of improper operation is avoided, and the time coordinating the closing and restarting process of the main program is realized, which can reduce the idle time in the process, thereby effectively improving the restart speed after the main program crashes.

Description of drawings

FIG. 1 is a schematic structural diagram of an embodiment of a system for dealing with application program crashes provided by the present invention;

FIG. 2 is a schematic flowchart of an embodiment of a method for dealing with application program crashes provided by the present invention;

FIG. 3 is a schematic flow diagram of an embodiment of obtaining a crash signal of an application provided by the present invention;

Fig. 4 is a schematic flowchart of an embodiment of closing the main program according to the crash signal and outputting the restart signal provided by the present invention.

detailed description

Preferred embodiments of the present invention will be described in detail below in conjunction with the accompanying drawings, wherein the accompanying drawings constitute a part of the application and together with the embodiments of the present invention are used to explain the principle of the present invention and are not intended to limit the scope of the present invention.

In the description of the present invention, the terms "first" and "second" are only used for descriptive purposes, and cannot be understood as indicating or implying relative importance or implicitly specifying the quantity of indicated technical features. Thus, the features defined as "first" and "second" may explicitly or implicitly include at least one of these features. In addition, "plurality" means at least two, such as two, three, etc., unless otherwise clearly and specifically defined.

In the description of the present invention, reference to "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment can be included in at least one embodiment of the present invention. The occurrences of this phrase in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. It is understood explicitly and implicitly by those skilled in the art that the described embodiments can be combined with other embodiments.

In the description of the present invention, the execution order of the steps between the processes is not limited to the order presented in the text, and the corresponding order can be adjusted or appear in parallel.

Before describing the embodiment, explain the main program, daemon program and SetUnhandledExceptionFilter:

The main program refers to the program that will crash probabilistically.

A daemon is a program that can obtain some operating parameters of the main program.

SetUnhandledExceptionFilter refers to the setting exception capture function in the Windows system. When an exception occurs in the main program process that causes a crash, the system will call the exception handling function set by SetUnhandledExceptionFilter.

At present, after a probabilistic crash of the application, the system will pop up an error report box to prevent the application process from exiting after the crash, so as to output the prompt of the application crash, and for this prompt, only when the error report box is manually processed Only then can the application process be closed. However, in the case of an application program crashing, the user is more concerned about the recovery of the application program, or whether it does not affect the use of other applications.

Therefore, in the prior art, there is a problem that the application program needs to be manually processed to close the application program when dealing with the crash of the application program.

In order to solve the above problems, the present invention provides a system, method and storage medium for coping with application program crashes, which will be described in detail below.

As shown in FIG. 1, FIG. 1 is a schematic structural diagram of an embodiment of a system for dealing with application program crashes provided by the present invention. The system 100 for dealing with application program crashes includes:

A crash signal acquisition module 101, configured to acquire a crash signal of an application program;

The crash exception processing module 102 is coupled with the crash signal acquisition module 101, and is used to close the main program according to the crash signal and output a restart signal;

The restart module 103, coupled with the crash exception processing module 102, is used to restart the main program according to the restart signal.

In this embodiment, firstly, the crash signal of the application program is obtained by the crash signal acquisition module 101 according to the operating parameters of the application program; then, the crash exception processing module 102 is activated under the action of the crash signal, and closes the main program according to the output of the crash signal and after the main program is completely closed, output a signal to restart the main program; finally, the restart module 103 restarts the main program driven by the restart signal.

In this embodiment, by setting the crash exception processing module 102, an instruction to close the main program is issued immediately after receiving the crash signal of the application program, so that the system receives the instruction of "closing the main program" before the system sends an error report frame, Avoid the system sending error report frame, thereby completely avoiding the problem of needing to manually close the error report frame; further, the crash exception processing module 102 in the present embodiment is also outputting a restart signal after confirming that the main program is completely closed, and restart module 103 according to The restart signal restarts the main program, thus restarting the application.

In this embodiment, the application program includes a main program and a daemon program. The main program is the main part of the application program and is related to the running of the application program. The daemon program is a marginal part of the application program and does not involve the running of the main program.

As a preferred embodiment, the crash signal collection module 101 includes a waiting unit for acquiring the crash signal of the application program according to the running state of the main program.

As a preferred embodiment, the crash exception processing module 102 includes a crash exception processing unit and a state judgment unit, wherein the crash exception processing unit is used to close the main program according to the crash signal, and the state judgment unit is used to output restart according to the opening and closing state of the main program Signal.

As a preferred embodiment, the restart module 103 includes creating a process unit for starting the main program according to the restart signal.

In order to solve the above problems, the present invention provides a method for dealing with application program crashes, as shown in FIG. 2 , which is a schematic flowchart of an embodiment of the method for dealing with application program crashes provided by the present invention, including:

Step S101: Obtain a crash signal of the application program.

Step S102: Close the main program according to the crash signal and output a restart signal.

Step S103: Restart the main program according to the restart signal.

In this embodiment, firstly, the crash signal of the application program is obtained; then, the main program is closed according to the crash signal, and a restart signal is output after the main program is completely closed; finally, the main program is restarted according to the restart signal.

In this embodiment, by closing the main program in the application program immediately after receiving the crash signal of the application program, thereby avoiding the system from generating an error report box; Start the main program, which improves the speed of restarting after the main program crashes.

As a preferred embodiment, in step S101, in order to obtain the crash signal of the application program, as shown in FIG. 3 , FIG. 3 is a schematic flowchart of an embodiment of obtaining the crash signal of the application program provided by the present invention, including:

Step S111: Set a waiting function, and obtain the running state of the main program according to the waiting function.

Step S112: According to the running state of the main program, determine whether to output a crash signal of the application program.

Step S113: When the running state of the main program is crash and exit, output the crash signal of the application program; when the running state of the main program is running normally, keep the current running state.

In this embodiment, the operating parameters of the main program are obtained by setting the waiting function, thereby correspondingly obtaining the operating state of the main program; then, according to the operating state of the main program, when the operating state of the main program is crash exit, the output application program The crash signal of the main program; when the running state of the main program is running normally, keep the current running state.

In a specific embodiment, the waiting function adopts the WaitForSingleObject function, the handle of the main program is used as the first parameter, the first parameter is handle, and INFINITE is used as the second parameter, indicating that the waiting time is infinite.

If the main program crashes and exits, the WaitForSingleObject function will return immediately, indicating that the state of the object pointed to by handle has changed, and output the crash signal of the application; if the main program is running normally, WaitForSingleObject will wait forever.

Specifically, the relevant pseudocodes running in the waiting function are as follows:

As a preferred embodiment, in step S102, in order to close the main program according to the crash signal and output a restart signal, as shown in Figure 4, Figure 4 is an embodiment of closing the main program according to the crash signal and outputting a restart signal provided by the present invention Schematic diagram of the process, including:

Step S121: Set a crash exception handling function and a state discrimination function.

Step S122: The crash exception handling function outputs an instruction to close the main program according to the crash signal.

Step S123: The state judging function judges whether to output a restart signal according to the on/off state of the main program.

Step S124: When the opening and closing state of the main program is closed, output a restart signal; when the opening and closing state of the main program is open, maintain the current running state.

In this embodiment, by setting the crash exception handling function, the command to close the main program can be output in time when the crash signal is obtained; Output the restart signal after closing, realize the output restart signal at the fastest speed, so as to improve the restart speed after the main program crashes.

As a preferred embodiment, in step S121, the crash exception handling function is set based on the SetUnhandledExceptionFilter function, as the SetUnhandledExceptionFilter function specified by the system to start after the application program crashes, the crash exception handling function is set based on it, which can be better Satisfy the adaptability as much as possible, and avoid the instability of the use process caused by the poor adaptability.

In a specific embodiment, the crash exception handling function adopts the UnhandledExceptionFilter function. After the crash signal is captured, the system calls the UnhandledExceptionFilter function. If the function directly returns EXCEPTION_EXECUTE_HANDLER, it means that the exception has been processed, so that the system will not create an error report box process. , thereby avoiding the manual handling of error reporting boxes by humans.

Specifically, the relevant pseudocode of the crash exception handling function is as follows:

(1) Define the crash exception handling function

(2) Register crash exception handling function

begin:

SetUnhandledExceptionFilter(UnhandledExcepFilter);

end;

As a preferred embodiment, in step S103, in order to restart the main program according to the restart signal, a restart function is set, and an instruction to restart the main program is output according to the restart signal.

In this embodiment, the restart signal is obtained in time through the restart function, and an instruction to restart the main program is output according to the restart signal, which can reduce the time for capturing the restart signal and effectively improve the restart speed of the main program after it crashes.

In a specific embodiment, the restart function adopts the CreateProcess function. After the restart signal is captured, the CreateProcess function is called to start the main program, and the handle of the main program returned by the CreateProcess function is preserved, wherein the handle is stored in a variable named Handle.

Through the above method, after detecting the signal of the application program crash, firstly, the crash exception handling function in the crash exception handling module guides the main program to close the action, thereby avoiding the system from generating an error report box and reducing the steps of manual operation; Then, restart the main program after confirming that the main program is completely closed, so as to restart the application program, not only avoiding the problem of improper operation, but also guiding the main program to restart based on the restart function in the restart module, realizing the shutdown and restart of the main program The time planning of the process can reduce the idle time in the process, thereby effectively improving the restart speed after the main program crashes.

In order to solve the above problems, the present invention also provides a computer-readable storage medium, on which a computer program is stored, wherein, when the computer program is running, the device where the computer-readable storage medium is located is controlled to execute any of the above technical solutions. A way to deal with application crashes.

Those of ordinary skill in the art can understand that all or part of the processes in the methods of the above embodiments can be implemented through computer programs to instruct related hardware, and the computer programs can be stored in a non-volatile computer-readable memory In the medium, when the computer program is executed, it may include the processes of the embodiments of the above-mentioned methods. Any reference to memory, storage, database or other media used in the various embodiments provided herein may include non-volatile and/or volatile memory. Nonvolatile memory can include read only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in many forms such as Static RAM (SRAM), Dynamic RAM (DRAM), Synchronous DRAM (SDRAM), Double Data Rate SDRAM (DDRSDRAM), Enhanced SDRAM (ESDRAM), Synchronous Chain Synchlink DRAM (SLDRAM), memory bus (Rambus) direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

The above is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any person skilled in the art within the technical scope disclosed in the present invention can easily think of changes or Replacement should be covered within the protection scope of the present invention.

Claims (10)

1. A system for dealing with application crashes, comprising: The crash signal acquisition module is used to acquire the crash signal of the application program; The crash exception processing module is coupled with the crash signal acquisition module, and is used to close the main program according to the crash signal and output a restart signal; The restart module, coupled with the crash exception processing module, is used to restart the main program according to the restart signal. 2. The system for dealing with application program crashes according to claim 1, wherein the crash signal acquisition module includes a waiting unit for obtaining the crash signal of the application program according to the running state of the main program . 3. The system for dealing with application program crashes according to claim 1, wherein the crash exception processing module includes a crash exception processing unit and a state judgment unit, wherein the crash exception processing unit is used to The signal closes the main program, and the state judging unit is configured to output the restart signal according to the on-off state of the main program. 4. The system for dealing with application program crashes according to claim 1, wherein the restart module includes creating a process unit for starting the main program according to the restart signal. 5. A method for dealing with application program crashes, comprising: Get the crash signal of the application; Close the main program according to the crash signal and output a restart signal; The main program is restarted according to the restart signal. 6. The method for dealing with application program crashes according to claim 5, wherein obtaining the application program's crash signal comprises: A waiting function is set, and the running state of the main program is obtained according to the waiting function; judging whether to output the crash signal of the application program according to the running state of the main program; When the running state of the main program is crash and exit, output the crash signal of the application program; when the running state of the main program is running normally, keep the current running state. 7. The method for dealing with application program crashes according to claim 5, wherein closing the main program according to the crash signal and outputting a restart signal comprises: Set crash exception handling function and state discrimination function; The crash exception processing function outputs an instruction to close the main program according to the crash signal; The state discrimination function judges whether to output the restart signal according to the on-off state of the main program; When the opening and closing state of the main program is closed, the restart signal is output; when the opening and closing state of the main program is open, the current running state is maintained. 8. The method for dealing with application program crashes according to claim 7, wherein the crash exception handling function is set based on the SetUnhandledExceptionFilter function. 9. The method for dealing with application program crashes according to claim 5, wherein restarting the main program according to the restart signal comprises: A restart function is set, and an instruction to restart the main program is output according to the restart signal. 10. A computer-readable storage medium, wherein a computer program is stored in the computer-readable storage medium, wherein when the computer program is running, the device where the computer-readable storage medium is located is controlled to execute the The method for dealing with application crash described in any one of 5 to 9.

Images