CN114371949A - Application program exception processing method, device, device and storage medium - Google Patents

Abstract

The application discloses a method, a device, equipment and a storage medium for processing application program exception, wherein the method comprises the following steps: monitoring the running state of the application program; when the application program runs abnormally, determining a system architecture layer corresponding to the abnormality; when the exception is located in an application layer, determining a category to which the exception belongs; determining an exception handling strategy according to the category of the exception; when the exception is positioned in the local framework layer, monitoring a signal in the exception through a signal processing function; when the exception includes a target signal, acquiring a current value of a target register; and adjusting the current value of the target register to a safe value so that the application program operates normally. By adopting the technical scheme, the method and the device adopt the graded recovery measures for the abnormity of the application program, reduce the flash back condition of the application program, and improve the running stability of the application program, thereby reducing the perception of the user to the abnormity and reducing the user loss of the application program.

Description

Application program exception processing method, device, device and storage medium

technical field

The present application relates to the field of mobile communication technologies, and in particular, to a method, apparatus, device, and storage medium for processing application program exceptions.

Background technique

In the prior art, a patch package (patch) needs to be created when processing an online exception of an application program. In this method, the application program (APP) needs to monitor whether an exception occurs on the user side in advance, and collect and report the exception information, but the user may The APP will be refused to collect and report these abnormal information. In addition, the patch production and distribution process is generally long, and more people need to be involved. It takes a certain amount of time from the occurrence of a crash on the client side to the monitoring of a large number of client-side crashes that trigger an alarm; to send a patch, you need to find the source code of the corresponding online version, and after locating and fixing the problem, you need to rebuild the apk and make a difference with the apk of the existing network Processing (diff); after the patch package is made, testers need to perform regression testing in the test environment. Various models and ROM versions need to be regressed once before they can be released to the live network; and they need to be released to the live network. The grayscale volume is increased, and the repair effect is observed, and the whole process is completed, which generally takes 2-3 hours. In addition, since it takes a certain amount of time to send a patch, it may appear as a continuous crash on the user side, which affects the user's normal use of the APP, and even causes user loss.

Therefore, it is necessary to provide a method, device, device, and storage medium for processing application program exceptions, and adopting hierarchical recovery measures for application program exceptions, thereby reducing application program flashbacks and improving application program operation stability.

SUMMARY OF THE INVENTION

The present application provides a method, device, device and storage medium for handling application program exceptions, which can reduce the flashback situation of application programs and improve the running stability of application programs, thereby reducing users' perception of exceptions and reducing the number of users of application programs. churn.

On the one hand, the present application provides a method for processing application exceptions, the method comprising:

Monitor the running status of the application;

When the application program runs abnormally, determine the system architecture layer corresponding to the abnormality;

When the exception is located at the application layer, determine the category to which the exception belongs;

Determine a processing strategy for the exception according to the category to which the exception belongs;

When the exception is located at the local framework layer, the signal in the exception is monitored through a signal processing function;

When the exception includes the target signal, obtain the current value of the target register;

The current value of the target register is adjusted to a safe value for the application to function properly.

Another aspect provides an apparatus for processing application exceptions, the apparatus comprising:

Status monitoring module for monitoring the running status of the application;

a system architecture layer determination module, configured to determine the system architecture layer corresponding to the exception when the application program runs abnormally;

a category determination module, configured to determine the category to which the exception belongs when the exception is located at the application layer;

a processing strategy determination module, configured to determine a processing strategy for the exception according to the category to which the exception belongs;

a signal monitoring module, used for monitoring the signal in the exception through a signal processing function when the exception is located at the local framework layer;

A current value acquisition module, configured to acquire the current value of the target register when the exception includes the target signal;

The current value adjustment module is configured to adjust the current value of the target register to a safe value, so that the application program can run normally.

Another aspect provides an application program exception processing device, the device includes a processor and a memory, the memory stores at least one instruction or at least a piece of program, the at least one instruction or the at least one piece of program is stored by the The processor is loaded and executed to implement the above-mentioned application program exception processing method.

Another aspect provides a computer-readable storage medium storing at least one instruction or at least one program, the at least one instruction or at least one program being loaded and executed by a processor to implement the above The application exception handling method.

The application program exception processing method, device, device and storage medium provided by this application have the following technical effects:

In this application, when the application program runs abnormally, the system architecture layer corresponding to the exception is determined, and different processing strategies are adopted for exceptions located at different layers; for application layer exceptions, corresponding processing strategies are adopted according to the exception category; for local framework layer exceptions, Bring the application back to normal by modifying the current value of the register. By adopting the technical solution of the present application, graded recovery measures are taken for the abnormality of the application program, the flashback of the application program is reduced, the running stability of the application program is improved, the user's perception of the abnormality is reduced, and the number of users of the application program is reduced. churn.

Description of drawings

In order to more clearly illustrate the technical solutions and advantages in the embodiments of the present application or in the prior art, the following briefly introduces the accompanying drawings used in the description of the embodiments or the prior art. Obviously, the accompanying drawings in the following description The drawings are only some embodiments of the present application. For those of ordinary skill in the art, other drawings can also be obtained based on these drawings without any creative effort.

FIG. 1 is a schematic diagram of a processing system for abnormal application programs provided by an embodiment of the present application;

2 is a schematic flowchart of a method for processing an application program exception provided by an embodiment of the present application;

3 is a schematic flowchart of a method for monitoring exceptions through Thread.uncaught Exception Handler (referred to as Uncaught Handler) provided by an embodiment of the present application;

FIG. 4 is a schematic flowchart of a method for determining an exception handling strategy according to the category to which the exception belongs, provided by an embodiment of the present application;

5 is a schematic flowchart of an exception handling method provided by an embodiment of the present application when the exception is located at the application layer and the category to which the exception belongs cannot be determined;

6 is a schematic flowchart of an exception processing method when a target thread provided by an embodiment of the present application does not include a message processing class;

7 is a schematic flowchart of a method for obtaining a current value of a target register provided by an embodiment of the present application;

8 is a schematic structural diagram of a blockchain system provided by an embodiment of the present application;

9 is a schematic diagram of a block structure provided by an embodiment of the present application;

FIG. 10 is a schematic structural diagram of an apparatus for processing application program exceptions provided by an embodiment of the present application;

FIG. 11 is a schematic structural diagram of a server provided by an embodiment of the present application.

Detailed ways

The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments are only a part of the embodiments of the present application, but not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative work shall fall within the protection scope of the present application.

It should be noted that the terms "first", "second" and the like in the description and claims of the present application and the above drawings are used to distinguish similar objects, and are not necessarily used to describe a specific sequence or sequence. It is to be understood that data so used may be interchanged under appropriate circumstances such that the embodiments of the application described herein can be practiced in sequences other than those illustrated or described herein. Furthermore, the terms "comprising" and "having" and any variations thereof, are intended to cover non-exclusive inclusion, for example, a process, method, system, product or server comprising a series of steps or units is not necessarily limited to those expressly listed Rather, those steps or units may include other steps or units not expressly listed or inherent to these processes, methods, products or devices.

Please refer to FIG. 1 . FIG. 1 is a schematic diagram of a system for processing application program exceptions provided by an embodiment of the present application. As shown in FIG. 1 , the system for processing application program exceptions may at least include a server 01 and a client 02 .

Specifically, in the embodiment of this specification, the server 01 may include an independently running server, or a distributed server, or a server cluster composed of multiple servers, and may also provide cloud services, cloud databases, cloud computing, cloud Cloud servers for basic cloud computing services such as functions, cloud storage, network services, cloud communications, middleware services, domain name services, security services, CDN (Content Delivery Network), and big data and artificial intelligence platforms. The server 01 may include a network communication unit, a processor, a memory, and the like. Specifically, the server 01 may be used to store the exception information of the application and the exception handling strategy.

Specifically, in the embodiment of this specification, the client 02 may include a smart phone, a desktop computer, a tablet computer, a notebook computer, a digital assistant, a smart wearable device, a vehicle-mounted terminal, and other types of physical devices, and may also include physical devices running on an entity Software in the device, such as web pages provided by some service providers to users, may also be applications provided by these service providers to users. Specifically, the client 02 can be used to determine the exception type of the application and process the exception of the application.

The following describes a method for processing application program exceptions of the present application. FIG. 2 is a schematic flowchart of a method for processing application program exceptions provided by an embodiment of the present application. This specification provides method operations as described in the embodiments or flowcharts. steps, but may include more or fewer operational steps based on routine or non-creative work. The sequence of steps enumerated in the embodiments is only one of the execution sequences of many steps, and does not represent the only execution sequence. When an actual system or server product is executed, it can be executed sequentially or in parallel (for example, a parallel processor or a multi-threaded processing environment) according to the embodiments or the methods shown in the accompanying drawings. Specifically, as shown in Figure 2, the method may include:

S201: Monitor the running state of the application program.

In the embodiment of this specification, the application program may be an application program in a terminal, for example, the application program may be a game application program, a news application program, a multimedia information application program, etc.; the running status of the application program is monitored by the terminal, and the running status may include normal Operating status and abnormal operating status.

S203: When the application program runs abnormally, determine the system architecture layer corresponding to the abnormality.

In the embodiments of this specification, the system architecture layer corresponding to the exception may include an application layer and a local framework layer. In the Android system, the application layer can be the JVM (Java Virtual Machine) layer, which refers to the Android (Android) application layer written in Java/Kotlin, generally a dex file, which is an executable file of the Android system, including All operation instructions and runtime data of the application; the local framework layer can be the native layer; the native layer refers to the Android dynamic link library written in c/c++, which is generally a so file; the so file is the program function library under Linux, that is Compiled code and data that can be used by other programs. During the running of the application, some series of abnormal conditions may be caused by factors such as insufficient memory and link errors. If the exception is not handled, the application will not be able to continue to run normally, and even the application may crash frequently. Case. Flashback refers to the sudden exit interruption when opening or using an application, which is manifested as a flash of the application screen and then back to the desktop. At this time, the corresponding exception handling strategy can be determined according to the system architecture layer corresponding to the abnormal situation. The technical solution of the present application is not only suitable for the Android system, but also can be extended to the iOS system and the windows system.

In the embodiments of this specification, testers will test and analyze the application program before it is officially put into application, and some anomalies can be found through testing, such as edge path anomaly, background configuration anomaly, interface data anomaly, individual read-only memory (Read Only Memory) anomalies. -Only Memory, ROM) compatibility exceptions, etc. For these exceptions, you can set the corresponding processing strategy, so as to avoid the pop-up window to inform the user, and it will not affect the user's normal use of the application. However, there are still exceptions that are not found by the tester, that is, uncaught exceptions, and the exceptions in the embodiments of this specification refer to uncaught exceptions.

S205: When the exception is located in the application layer, determine the category to which the exception belongs.

In the embodiment of this specification, in the Android system, the application layer may be a JVM (Java Virtual Machine) layer; the category to which the exception belongs may include an insufficient memory exception, a link error exception, or other serious exceptions loaded into the blacklist. In the Android system, you can monitor exceptions by registering Thread.uncaught Exception Handler, and handle the exception information appropriately, so as to bypass the system to kill the abnormal process and prevent the application from crashing.

In a specific embodiment, as shown in Figure 3, Figure 3 is a flowchart of a method for monitoring exceptions through Thread.uncaught ExceptionHandler (referred to as Uncaught Handler). First, a process is created in the application program, and then the Uncaught Handler application program interface is called, Monitor the process by running the Uncaught Handler to determine whether the process in the application is abnormal. If so, find out whether there is a catch block corresponding to the abnormal process, so as to determine the uncaught exception and destroy the abnormal thread, and continue to return after destroying the abnormal thread. The step of calling UncaughtHandler; if there is no catch block corresponding to the abnormal process, return to the step of running the Uncaught Handler. Calling the Uncaught Handler API can kill the abnormal process in the application, and can also send a pop-up message to the server to inform the tester of the specific flashback crash information. The tester can be the developer of the application; the pop-up message can be sent in the form of a toast prompt box. The toast prompt box is a non-modal pop-up window that pops up a small message as a reminder or message feedback. to display the result of an operation, or a change in application state. For example, when the user sends a text message, the App pops up a Toast to remind the user that the message has been sent.

S207: Determine an exception handling strategy according to the category to which the exception belongs.

In the embodiment of the present specification, different functions may be called to determine a processing strategy to process the exception according to the category to which the exception belongs, so as to prevent the application from crashing.

Specifically, in the embodiment of the present specification, as shown in FIG. 4 , according to the category to which the exception belongs, the processing strategy for determining the exception may include:

S2071: When the exception is insufficient memory, perform memory cache cleaning and ignore the exception.

In the embodiment of this specification, out of memory (OMO) refers to insufficient internal storage space of the application program. At this time, memory cleaning needs to be performed to release the memory space; when the memory cache cleaning is performed, the image library memory cache can be performed. Cleanup; ignoring exceptions means that the application will not flash back, and the current page will still be displayed. After the memory cache is cleaned up, the application will continue to run normally. In the Android system, the exception can be ignored by calling the Application Programming Interface (API) of Finalize time outException.

S2073: When the exception is a link error, close the exception plug-in.

In the embodiment of this specification, the link error may be Linkage Error, and for the WeChat application, the Linkage Error may be the link error of WeChat Moments. At this time, you can close the corresponding plug-in in the circle of friends to avoid the flashback of the WeChat application.

Specifically, in the embodiment of this specification, when the exception is a link error, closing the exception plug-in may include:

S20731: When the exception is a link error, determine the exception stack information corresponding to the exception;

In the embodiment of this specification, the information of the exception stack corresponding to the exception can be determined through the Linkage Error application program interface.

S20733: Determine the exception plug-in according to the exception stack information;

In the embodiment of the present specification, the exception plug-in corresponding to the exception may be determined through the relevant attribute information of the exception stack.

S20735: Close the abnormal plug-in.

In the embodiment of this specification, the exception in the application program can be eliminated by closing the exception plug-in, so as to avoid the application program from flashing back. This operation also refers to ignoring the exception in the application program.

S2075: When the exception is an exception in the blacklist, restart the application and jump to the target page, where the target page is the page before the application restarts.

In the embodiment of this specification, the exceptions in the blacklist can be customized exceptions by testers; such exceptions usually refer to serious exceptions that cannot be handled by the system. Use exceptions or exceptions that cannot be handled by other systems. The target page is the page before the application restarts, that is, the last page the user stays before the application restarts. For this exception, the application needs to be restarted, and the page after the restart is the last page the user stayed before the restart, so that the application corresponds to the user to continue to browse the page that was left before, and there is no need to start browsing from the home page of the application, which improves the user's experience. Browsing efficiency. In the embodiment of this specification, a user refers to a user who is using an application program.

In the embodiment of this specification, as shown in FIG. 5 , when the exception is located at the application layer and the category to which the exception belongs cannot be determined, the method may further include:

S2061: Call the system application program interface to determine the target thread corresponding to the exception;

In the embodiment of this specification, the system application program interface can be Thread.uncaught ExceptionHandler, through which the target thread corresponding to the exception currently occurring in the application program can be obtained. The target thread is the thread corresponding to the exception, and the thread is the task scheduling and execution. basic unit. Handler is mainly used for asynchronous message processing: when a message is sent, it first enters a message queue, the function that sends the message returns immediately, and the other part takes out the messages one by one in the message queue, and then processes the message, that is, sends Messages and receiving messages are not synchronous processes. This mechanism is usually used to handle relatively time-consuming operations.

S2063: Determine whether the target thread includes a message processing class;

In the embodiment of this specification, the message processing class can be the Looper class; Handler has an important member variable Looper, which maintains a message queue (Message Queue), when we use handler.post or send Message related methods are all Is to put the message Message into the message queue. Each thread will have its own Looper.

The Looper class in Android is a class used to encapsulate message loops and message queues for message processing in android threads. Handler can actually be seen as a tool class used to insert messages into the message queue.

(1) The Looper class is used to open a message loop for a thread.

By default, the newly born thread in android does not open the message loop. (Except the main thread, the main thread system will automatically create a Looper object for it and open the message loop.)

Looper objects store messages and events through Message Queue. A thread can only have one Looper, corresponding to one Message Queue.

(2) It usually interacts with Looper through the Handler object. Handler can be regarded as an interface of Looper, which is used to send messages and define processing methods to the specified Looper.

By default, Handler is bound to the Looper of the thread where it is defined. For example, if Handler is defined in the main thread, it is bound to the Looper of the main thread.

S2065: If the target thread includes a message processing class, determine whether the target thread is the main thread;

Specifically, in the embodiment of this specification, when the target thread includes a message processing class Looper, it is further judged whether the target thread is the main thread. The main thread is when a program starts, a process is created by the operating system (OS), and a thread runs immediately at the same time. Because it is executed at the beginning of the program, if you need to create a thread, the created thread is a child thread of the main thread. Each process has at least one main thread. In Winform, it should be the thread that creates the GUI. The importance of the main thread is reflected in two aspects: 1. It is the thread that spawns other sub-threads; 2. Usually it must complete the execution at the end, such as performing various shutdown actions. Each thread has a unique identifier to distinguish the primary and secondary relationship in the thread.

Thread unique identifier: Thread.CurrentThread.ManagedThreadID; for example, both the UI interface and the Main function are the main thread. The "method body" or "delegate" contained by Thread are all child threads. A delegate can contain multiple method bodies, which are executed using this.Invoke. You can also define multiple method bodies and put them in Thread to execute. Then this method body is a child thread.

In the embodiment of this specification, whether the target thread is the main thread can be determined through the first function; the first function can be Looper.loop().

S2067: If the target thread is the main thread, close the current page corresponding to the target thread;

In the embodiment of the present specification, when the target thread is the main thread, the current page corresponding to the target thread needs to be closed, so as to prevent the application program from crashing.

S2069: If the target thread is a non-main thread, continue to run the target thread.

In the embodiment of this specification, when the target thread is a non-main thread, the target thread can be a sub-thread, and when the target thread is a sub-thread, the exception can be ignored and the target thread can continue to run.

Specifically, in the embodiment of this specification, as shown in FIG. 6 , if the target thread does not include a message processing class, the method may further include:

S20661: Determine whether the target thread is an abnormal thread;

In the embodiment of the present specification, whether the target thread is an abnormal thread can be determined through a second function; the second function can be Thread.run().

S20663: If the target thread is an abnormal thread, close the abnormal thread;

In the embodiment of the present specification, by finding and closing the abnormal thread, the application program can be prevented from crashing.

S20665: If the target thread is a non-abnormal thread, continue to run the target thread.

S209: When the exception is located at the local framework layer, the signal in the exception is monitored through the signal processing function.

In the embodiments of this specification, in the Android system, the local framework layer may be the Native layer, wherein the signal processing function may be the signal function, and the signal in the exception may be monitored by registering the signal function.

S2011: When the exception includes the target signal, obtain the current value of the target register.

In the embodiment of this specification, the target signal may include signals such as sigsegv, sigabrt, etc. When the target signal is monitored, the current value of the target register is acquired.

In the embodiment of this specification, as shown in FIG. 7 , when the exception includes the target signal, acquiring the current value of the target register includes:

S20111: When the exception includes the target signal, obtain the context information of the exception;

In the embodiment of the present specification, the context information (context) of the exception may include the value and status information of each register.

S20113: Acquire the current value of the target register according to the abnormal context information.

In this embodiment of the present specification, the current value of the target register may be determined through context. The target register can include the PC register and the SP register; the PC register is responsible for storing the memory address, which points to the next instruction to be executed. After each instruction is interpreted and executed, the value of the pc register will be automatically updated to the address of the next instruction; PC is a 16-bit program counter (Program Counter), which does not belong to the category of special function registers. Programmers do not access the PC like accessing special function registers. The SP (Stack Pointer) register refers to the stack pointer register, which indicates the top address of the stack.

S2013: Adjust the current value of the target register to a safe value to make the application run normally.

In the embodiments of this specification, when an exception occurs, the current value of the target register is the abnormal value, the value of the target register can be modified to a safe value, the exception method can be bypassed, and another method can be used to continue executing the application program. current process, thus guaranteeing the normal operation of the application.

Specifically, in the embodiment of this specification, before the step of adjusting the current value of the target register to a safe value so that the application program runs normally, the method may further include:

Through the context information of the exception, backtrack the call stack of the exception.

Specifically, in the embodiment of this specification, the context information of the exception, that is, the stack frame of the signal processing function, will record the address of the current stack, the value of the register, and the address of the return value (ret) of the function. Through these information, the call can be traced back. Stack, this is the principle of back trace.

In the embodiments of this specification, a call stack (Call stack), referred to as "the stack" for short, is also referred to as an execution stack (execution stack), a control stack (control stack), and a run-time stack (run-time stack). ) and the machine stack, a stack in computer science that stores messages about running subroutines. Sometimes just called "stack", but the stack does not necessarily store only subroutine messages. Almost all computer programs rely on call stacks, however high-level languages generally hide the details of the call stack into the background.

The call stack is most often used to store the return address of a subroutine. When calling any subroutine, the main program must temporarily store the address to which the subroutine should return after running. Therefore, if the called subroutine also calls other subroutines, its own return address must be stored in the call stack, and then retrieved after its own execution. In a recursive program, each level of recursion must add an address to the call stack, so if the program has infinite recursion (or just too many levels of recursion), the call stack will overflow.

The main function of the call stack is to store the return address. In addition, the call stack is also used to store:

· Local variables: The variables of subroutines can be stored in the call stack, which can achieve the effect of separating variables between different subroutines.

· Parameter passing: If the register is not enough to hold the parameters of the subroutine, the parameters can be stored on the call stack.

·Environment transfer: Some languages (such as Pascal and Ada) support "multi-layer subprograms", that is, the local variables of the main program can be used in the subprograms. These variables can be passed into subroutines via the call stack.

In the embodiment of this specification, adjusting the current value of the target register to a safe value so that the application program runs normally includes:

Adjust the value of the target register to a safe value through the call stack for the application to function properly.

In the embodiments of the present specification, the value of the target register can be modified through the call stack, for example, the values of the PC register and the SP register can be modified respectively within the safe range of each register through the call stack, so as to avoid application program flashback.

In the embodiments of this specification, when an exception occurs, for non-serious exceptions, methods such as automatic retry and ignoring are adopted to reduce user perception; for serious exceptions, the last page the user stayed on will be automatically restarted to avoid pop-up windows disturbing the user ; Due to the adoption of graded recovery measures, the user's perception of abnormality is greatly reduced, the experience of using the main path is guaranteed, more time is gained for sending patch packages (patch), the stability of the application is improved, and the User complaints.

In the embodiment of this specification, when the application program runs abnormally and resumes normal operation, the method further includes:

Send a prompt message to the server, and the prompt message includes the exception information of the application and the exception handling strategy.

In the embodiment of this specification, after the exception processing of the application program is completed, a prompt message may be sent to the background server corresponding to the application program, so that the server stores the exception information of the application program and the exception handling strategy.

Specifically, in the embodiment of this specification, the method may further include:

The server stores the exception information of the application and the exception handling strategy based on the blockchain system. The blockchain system includes multiple nodes, and a peer-to-peer network is formed between the multiple nodes.

In some embodiments, the blockchain system may be the structure shown in FIG. 8 , a peer-to-peer (P2P, Peer To Peer) network is formed between multiple nodes, and the P2P protocol is a transmission control protocol (TCP, Transmission Control Protocol) application layer protocol above the protocol. In the blockchain system, any machine such as server and terminal can join to become a node, and the node includes hardware layer, middle layer, operating system layer and application layer.

The functions of each node in the blockchain system shown in Figure 8 include:

1) Routing, a basic function that a node has to support communication between nodes.

In addition to the routing function, a node can also have the following functions:

2) Application, used to deploy in the blockchain, implement specific business according to actual business needs, record data related to the realization of functions to form record data, carry a digital signature in the record data to indicate the source of the task data, and send the record data To other nodes in the blockchain system, for other nodes to add the record data to the temporary block when verifying the source and integrity of the record data successfully.

3) Blockchain, including a series of blocks (Blocks) that follow each other in chronological order. Once a new block is added to the blockchain, it will not be removed. The block records the blockchain system. The record data submitted by the middle node.

In some embodiments, the block structure (Block Structure) may be the structure shown in FIG. 9 , and each block includes the hash value of the transaction record stored in the block (the hash value of the block), and the previous block. The hash value of a block, each block is connected by the hash value to form a blockchain. In addition, the block may also include information such as a timestamp when the block was generated. Blockchain (Block chain) is essentially a decentralized database, which is a series of data blocks associated with cryptographic methods. Each data block contains relevant information to verify the validity of its information. security (anti-counterfeiting) and generating the next block.

It can be seen from the technical solutions provided by the above embodiments of this specification that when an application program runs abnormally in the embodiments of this specification, the system architecture layer corresponding to the exception is determined, and different processing strategies are adopted for exceptions located at different layers; for application layer exceptions, Corresponding processing strategies are adopted according to the exception category; for local framework layer exceptions, the application program can be restored to normal by modifying the current value of the register. By adopting the technical solution of the present application, graded recovery measures are taken for the abnormality of the application program, the flashback of the application program is reduced, the running stability of the application program is improved, the user's perception of the abnormality is reduced, and the number of users of the application program is reduced. churn.

The embodiment of the present application also provides an apparatus for processing an application program exception. As shown in FIG. 10 , the apparatus includes:

a state monitoring module 1010, used to monitor the running state of the application;

The system architecture layer determination module 1020 is configured to determine the system architecture layer corresponding to the exception when the application program runs abnormally;

a category determination module 1030, configured to determine the category to which the exception belongs when the exception is located at the application layer;

a processing strategy determining module 1040, configured to determine a processing strategy for the exception according to the category to which the exception belongs;

The signal monitoring module 1050 is used to monitor the abnormal signal through the signal processing function when the abnormality is located in the local framework layer;

The current value obtaining module 1060 is configured to obtain the current value of the target register when the target signal is included in the exception;

The current value adjustment module 1070 is configured to adjust the current value of the target register to a safe value, so that the application program can run normally.

In some embodiments, the processing policy determination module may include:

a first processing module, configured to perform memory cache cleaning and ignore the exception when the exception is insufficient memory;

a second processing module, configured to close the exception plug-in when the exception is a link error;

A third processing module, configured to restart the application and jump to a target page when the exception is an exception in the blacklist, where the target page is the page before the application is restarted.

In some embodiments, the second processing module may include:

an exception stack information determination unit, configured to determine the exception stack information corresponding to the exception when the exception is a link error;

an exception plug-in determining unit, configured to determine the exception plug-in according to the exception stack information;

The abnormal plug-in closing unit is used to close the abnormal plug-in.

In some embodiments, when the exception is located at the application layer and the category to which the exception belongs cannot be determined, the apparatus may further include:

a target thread determination module, used to call the system application program interface to determine the target thread corresponding to the exception;

a first judgment module, used for judging whether the target thread includes a message processing class;

A second judgment module, configured to judge whether the target thread is the main thread if the target thread includes a message processing class;

The current page closing module is used to close the current page corresponding to the target thread if the target thread is the main thread;

The first target thread running module is configured to continue to run the target thread if the target thread is a non-main thread.

In some embodiments, if the target thread does not include a message processing class, the apparatus may further include:

an abnormal thread judgment module, used for judging whether the target thread is an abnormal thread;

an abnormal thread closing module, used to close the abnormal thread if the target thread is an abnormal thread;

The second target thread running module is configured to continue to run the target thread if the target thread is a non-abnormal thread.

In some embodiments, the current value obtaining module may include:

a context information acquisition unit, configured to acquire context information of the exception when the exception includes a target signal;

The current value obtaining unit is configured to obtain the current value of the target register according to the context information of the exception.

In some embodiments, the apparatus may also include:

The call stack backtracking module is used to backtrack the call stack of the exception through the context information of the exception.

In some embodiments, the current value adjustment module may include:

The current value adjustment unit is configured to adjust the value of the target register to a safe value through the call stack, so that the application program can run normally.

The apparatus and method embodiments in this apparatus embodiment are based on the same inventive concept.

An embodiment of the present application provides a device for processing application program exceptions, the device includes a processor and a memory, the memory stores at least one instruction or at least a piece of program, and the at least one instruction or at least a piece of program is loaded by the processor and executed. Execute to implement the application exception processing method provided by the above method embodiments.

Embodiments of the present application further provide a computer-readable storage medium, where the computer-readable storage medium can be set in a terminal to store at least one instruction related to implementing an application exception processing method in the method embodiment Or at least one piece of program, the at least one instruction or at least one piece of program is loaded and executed by the processor to implement the application program exception processing method provided by the above method embodiments.

Optionally, in this embodiment of the present specification, the storage medium may be located in at least one network server among multiple network servers of a computer network. Optionally, in this embodiment, the above-mentioned storage medium may include but is not limited to: a U disk, a read-only memory (ROM, Read-Only Memory), a random access memory (RAM, Random Access Memory), a mobile hard disk, a magnetic Various media that can store program codes, such as discs or optical discs.

The memory in the embodiments of this specification may be used to store software programs and modules, and the processor executes various functional applications and data processing by running the software programs and modules stored in the memory. The memory may mainly include a stored program area and a stored data area, wherein the stored program area may store the operating system, application programs required for functions, etc.; the stored data area may store data created according to the use of the device, and the like. Additionally, the memory 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. Accordingly, the memory may also include a memory controller to provide processor access to the memory.

The embodiments of the methods for processing application program exceptions provided by the embodiments of the present application may be executed in a mobile terminal, a computer terminal, a server, or a similar computing device. Taking running on a server as an example, FIG. 11 is a hardware structural block diagram of a server of a method for processing an application program exception provided by an embodiment of the present application. As shown in FIG. 11 , the server 1100 may vary greatly due to different configurations or performance, and may include one or more central processing units (Central Processing Units, CPU) 1110 (the processor 1110 may include but is not limited to a microprocessor MCU or programmable logic device FPGA, etc.), memory 1130 for storing data, one or more storage media 1120 (eg, one or more mass storage devices) for storing application programs 1123 or data 1122. Among them, the memory 1130 and the storage medium 1120 may be short-term storage or persistent storage. The program stored in the storage medium 1120 may include one or more modules, and each module may include a series of instruction operations on the server. Further, the central processing unit 1110 may be configured to communicate with the storage medium 1120 to execute a series of instruction operations in the storage medium 1120 on the server 1100 . Server 1100 may also include one or more power supplies 1160, one or more wired or wireless network interfaces 1150, one or more input and output interfaces 1140, and/or, one or more operating systems 1121, such as Windows Server™, Mac OS XTM, UnixTM, LinuxTM, FreeBSDTM and so on.

Input-output interface 1140 may be used to receive or transmit data via a network. The specific example of the above-mentioned network may include the wireless network provided by the communication provider of the server 1100 . In one example, the I/O interface 1140 includes a network adapter (Network Interface Controller, NIC), which can be connected to other network devices through the base station so as to communicate with the Internet. In one example, the input/output interface 1140 may be a radio frequency (Radio Frequency, RF) module, which is used to communicate with the Internet in a wireless manner.

Those of ordinary skill in the art can understand that the structure shown in FIG. 11 is only a schematic diagram, which does not limit the structure of the above-mentioned electronic device. For example, the server 1100 may also include more or fewer components than shown in FIG. 11 , or have a different configuration than that shown in FIG. 11 .

The present application provides a computer program product or computer program comprising computer instructions stored in a computer-readable storage medium. The processor of the computer device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions to cause the computer device to perform the methods provided in the various optional implementations described above.

It can be seen from the above-mentioned embodiments of the application program exception processing method, device, device or storage medium provided in this application that when the application program runs abnormally in this application, the system architecture layer corresponding to the exception is determined, and the exceptions located at different layers are taken. Different processing strategies; for application layer exceptions, corresponding processing strategies are adopted according to the exception category; for local framework layer exceptions, the application program can be restored to normal by modifying the current value of the register. By adopting the technical solution of the present application, graded recovery measures are taken for the abnormality of the application program, the flashback of the application program is reduced, the running stability of the application program is improved, the user's perception of the abnormality is reduced, and the number of users of the application program is reduced. churn.

It should be noted that: the above-mentioned order of the embodiments of the present application is only for description, and does not represent the advantages and disadvantages of the embodiments. And the foregoing describes specific embodiments of the present specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims can be performed in an order different from that in the embodiments and still achieve desirable results. Additionally, the processes depicted in the figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

Each embodiment in this specification is described in a progressive manner, and the same and similar parts between the various embodiments may be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the apparatus, equipment, and storage medium embodiments, since they are basically similar to the method embodiments, the description is relatively simple, and for related parts, please refer to the partial descriptions of the method embodiments.

Those of ordinary skill in the art can understand that all or part of the steps of implementing the above embodiments can be completed by hardware, or can be completed by instructing relevant hardware through a program, and the program can be stored in a computer storage medium. The above-mentioned storage The medium can be read-only memory, magnetic disk or optical disk, etc.

The above are only preferred embodiments of the present application and are not intended to limit the present application. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present application shall be included in the protection scope of the present application. Inside.

Claims (10)

1. a processing method of application program exception, is characterized in that, described method comprises: Monitor the running status of the application; When the application program runs abnormally, determine the system architecture layer corresponding to the abnormality; When the exception is located at the application layer, determine the category to which the exception belongs; Determine a processing strategy for the exception according to the category to which the exception belongs; When the exception is located at the local framework layer, the signal in the exception is monitored through a signal processing function; When the exception includes the target signal, obtain the current value of the target register; The current value of the target register is adjusted to a safe value for the application to function properly. 2 . The method according to claim 1 , wherein the determining of a processing strategy for the exception according to the category to which the exception belongs comprises: 2 . When the exception is insufficient memory, perform memory cache cleaning and ignore the exception; When the exception is a link error, close the exception plug-in; When the exception is an exception in the blacklist, restart the application and jump to a target page, where the target page is the page before the application is restarted. 3. The method according to claim 2, wherein when the exception is a link error, closing the exception plug-in comprises: When the exception is a link error, determine the exception stack information corresponding to the exception; According to the exception stack information, determine the exception plug-in; Close the exception plugin. 4. The method according to claim 1, wherein when the exception is located at the application layer and the category to which the exception belongs cannot be determined, the method further comprises: Calling the system application program interface to determine the target thread corresponding to the exception; Determine whether the target thread includes a message processing class; If the target thread includes a message processing class, determine whether the target thread is the main thread; If the target thread is the main thread, close the current page corresponding to the target thread; If the target thread is a non-main thread, continue to run the target thread. 5. The method according to claim 4, wherein, if the target thread does not include a message processing class, the method further comprises: Determine whether the target thread is an abnormal thread; If the target thread is an abnormal thread, close the abnormal thread; If the target thread is a non-abnormal thread, continue to run the target thread. 6. The method according to claim 1, wherein when the exception includes a target signal, acquiring the current value of the target register comprises: When the exception includes a target signal, obtain context information of the exception; Acquire the current value of the target register according to the context information of the exception. 7. The method according to claim 1, wherein before the step of adjusting the current value of the target register to a safe value so that the application program runs normally, the method further comprises: Backtracking the call stack of the exception through the context information of the exception; The adjusting the current value of the target register to a safe value to make the application run normally includes: The value of the target register is adjusted to a safe value through the call stack, so that the application program can run normally. 8. An apparatus for processing abnormality of an application program, wherein the apparatus comprises: Status monitoring module for monitoring the running status of the application; a system architecture layer determination module, configured to determine the system architecture layer corresponding to the exception when the application program runs abnormally; a category determination module, configured to determine the category to which the exception belongs when the exception is located at the application layer; a processing strategy determination module, configured to determine a processing strategy for the exception according to the category to which the exception belongs; a signal monitoring module, used for monitoring the signal in the exception through a signal processing function when the exception is located at the local framework layer; A current value acquisition module, configured to acquire the current value of the target register when the exception includes the target signal; The current value adjustment module is configured to adjust the current value of the target register to a safe value, so that the application program can run normally. 9. A processing device for abnormal application programs, characterized in that the device comprises a processor and a memory, and the memory stores at least one instruction or at least one program, and the at least one instruction or the at least one program consists of The processor loads and executes to implement the application program exception processing method according to any one of claims 1-7. 10. A computer-readable storage medium, characterized in that, the computer-readable storage medium stores at least one instruction or at least one program, and the at least one instruction or the at least one program is loaded and executed by a processor to The method for handling application program exceptions according to any one of claims 1-7 is implemented.

Images