CN108563581A - Abnormality detection processing method and apparatus, electronic device, and computer storage medium - Google Patents

Abstract

The embodiment of the invention discloses an anomaly detection and processing method and device, electronic equipment, and a computer storage medium. The abnormal detection processing method includes: creating a first thread group; creating an exception processing method in the first thread group; using the first thread group to replace the second thread group of the application program to perform exception processing.

Description

Abnormal detection and processing method and device, electronic equipment and computer storage medium

technical field

The present invention relates to the field of information technology, in particular to an abnormality detection and processing method and device, electronic equipment and computer storage medium.

Background technique

The application program may crash due to some abnormal reasons during operation. In order to facilitate the developer to obtain the cause of the program crash, the exception of the application program will be captured. For example, in the Android application (Application, APP), mainly through setting The thread's custom exception capture processing class, so as to capture the crash exception through the custom exception capture processing class. After the exception is caught, it is possible to repair the exception, so that the APP can run well as a whole and ensure user satisfaction. However, practice has found that in some cases, there are omissions or interruptions in the exception capture of the APP in the exception capture.

Contents of the invention

In view of this, the embodiments of the present invention expect to provide an anomaly detection and processing method and device, electronic equipment, and computer storage medium, which at least partially solve the problem of missing exception processing such as APP exception capture.

Technical scheme of the present invention is realized like this:

In a first aspect, an embodiment of the present invention provides an abnormality detection and processing method, including:

Create the first thread group;

creating an exception handling method within the first thread group;

Using the first thread group to replace the second thread group of the application program for exception handling.

Optionally, the creating an exception handling method in the first thread group includes:

creating a second exception handling method within the first thread group;

Set the method name of the first exception handling method of the application as the method name of the second exception handling method.

Optionally, the exception handling logic of the second exception handling method is at least partially different from the exception handling logic of the first exception handling method.

Optionally, the second exception method includes:

Inherited said first exception handling method;

A third exception handling method is created; wherein, the exception handling logic of the third exception handling method is different from the exception handling logic of the first exception handling method.

Optionally, the creating an exception handling method in the first thread group includes:

The exception handling method is created in the first thread group by using an overriding mechanism.

Optionally, the method also includes at least one of the following:

setting the attributes of the first thread group according to the attributes of the second thread group;

Setting the reference of the first thread group based on the reference of the second thread group.

Optionally, the setting the attribute of the first thread group according to the attribute of the second thread group includes at least one of the following:

Setting the thread group name of the first thread group according to the thread group name of the second thread group;

Setting the thread group information included in the first thread group according to the thread information included in the second thread group;

The type of the first thread group is set according to the type of the second thread group, wherein the type includes: a foreground thread group type and/or a background thread group type.

Optionally, the setting the attribute of the first thread group according to the attribute of the second thread group includes:

Using a reflection mechanism to set the attributes of the first thread group according to the attributes of the second thread group.

Optionally, using the first thread group to replace the second thread group of the application program to perform exception handling includes:

The first thread group receives an exception capture event from an operating system;

The exception catching method of the first thread group performs exception catching based on an exception catching event.

In a second aspect, an embodiment of the present invention provides an abnormality detection and processing device, including:

The first creation module is used to create the first thread group;

A second creating module, configured to create an exception handling method in the first thread group;

The replacement processing module is used to use the first thread group to replace the second thread group of the application program to perform exception processing.

In a third aspect, an embodiment of the present invention provides an electronic device, including:

memory for information storage;

A processor, connected to the memory, configured to implement the method provided by the foregoing one or more technical solutions by executing computer-executable instructions stored in the memory.

In a fourth aspect, an embodiment of the present invention provides a computer storage medium, the computer storage medium stores computer-executable instructions; after the computer-executable instructions are executed, the method provided by one or more of the foregoing technical solutions can be implemented.

The anomaly detection and processing method and device, electronic equipment, and computer storage medium provided by the embodiments of the present invention will create a first thread group, and use the thread group-level exception processing method of the first thread group to replace the second thread group to perform exception capture, etc. Exception handling, so as to reduce the problem that the thread-level exception catching events are not transmitted to each other, resulting in missing exception catching, so as to achieve comprehensive exception handling, and reduce omissions or interruptions such as exception catching and other exception handling.

Description of drawings

Fig. 1 is a schematic flow chart of the first abnormality detection and processing method provided by the embodiment of the present invention;

FIG. 2 is a system block diagram of an electronic device provided by an embodiment of the present invention;

FIG. 3 is a schematic structural diagram of an electronic device provided by an embodiment of the present invention;

FIG. 4 is a schematic flowchart of a second anomaly detection and processing method provided by an embodiment of the present invention.

Detailed ways

The technical solutions of the present invention will be further described in detail below in conjunction with the accompanying drawings and specific embodiments.

The research found that the problem of missing or interrupting the exception capture is: in the related technologies, the exception capture at the thread level is carried out; after the operating system finds the exception, it notifies the thread group; the thread group informs the thread that first established the exception capture method to capture the exception; if After a thread completes the exception capture, if it does not pass the exception capture event to other programs, it will cause the interruption of the capture, which will lead to the problem of missing exception capture. If a third-party software development tool (Software Development Kit, SDK) or a third-party plug-in is introduced into an application program, since the abnormal program developed by itself in the abnormal program will not know the SDK or third-party plug-in provided by the third party, it is obviously even worse. The exception capture event may be passed to the third-party SDK or third-party plug-in, so the exception detection of the application installed with the third-party SDK or third-party plug-in is always missing.

As shown in FIG. 1, this embodiment provides a method for abnormality detection and processing, including:

Step S110: creating a first thread group;

Step S120: Create an exception handling method in the first thread group;

Step S130: Use the first thread group to replace the second thread group of the application program to perform exception handling.

In this embodiment, the first thread group may be independent from the second thread group. The second thread group can be any thread group that can receive the exception capture event provided by the operating system. For example, the second thread group can be the main thread group where the main function is located, and the main function can include: main ()function. For another example, the second thread group may also be other thread groups used for exception handling such as exception capture, and is not limited to the main thread group where the main function is located.

In this embodiment, the first thread group may be a temporary or dynamically created thread group.

In some embodiments, step S110 may include: creating the first thread group when the application starts or after starting. In this way, the first thread group is created every time the application program starts or after startup, even if the application program is updated (for example, a new plug-in or patch is introduced), the exception handling method included in the first thread group can be adjusted in time , to achieve comprehensive handling of exceptions such as exception capture, avoiding omissions and exception handling interruptions.

In some embodiments, the step S110 may further include: when the application program is updated, creating the first thread group; otherwise, using the first thread group created before the previous application program is closed for exception handling, reducing the first Processes such as thread group creation. Here, the update of the application program may include: code update and/or configuration information of the abnormal program, for example, the application program has a new plug-in and/or a new patch.

In some embodiments, an execution code and execution parameters for creating the first thread group are set in the application program. After the execution code is called, the first thread group will be created based on the execution parameters. The execution parameters may include : Parameters such as the thread group object of the first thread group. In some other embodiments, the calling of the executing code may further include: applying to the operating system for creating and using the resources of the first thread group, and the resources may include: storage resources and/or computing resources, and the like.

In this embodiment, the first thread group may be created based on the thread group class of the first thread group; for example, the first thread group of the same type as the second thread group is created.

An exception handling method is created in the first thread group, and the exception handling method can be various program codes, which directly belong to the exception handling method of the thread group.

In this embodiment, the second thread group created is used to directly perform exception handling, so if the operating system finds an exception, an exception capture event will be generated and the second thread group notified; Capture, obviously there is no transfer of exception capture between different threads, and there is no problem of missing exception capture due to interruption of exception capture event transmission. The exception catching event sent by the operating system will trigger the corresponding thread group or thread to perform exception handling. For example, the exception handling may include: one or more of exception catching, exception locating, exception recording, and exception reporting.

Optionally, the step S120 may include:

creating a second exception handling method within the first thread group;

Set the method name of the first exception handling method of the application as the method name of the second exception handling method.

Optionally, the exception handling logic of the second exception handling method is at least partially different from the exception handling logic of the first exception handling method.

In this embodiment, in order to realize the processing of exception capture, the server platform can be smoothly notified of the caught exception. In this embodiment, a second exception handling method is created, and the second exception handling method may be: the exception handling logic at the thread group level and/or the exception handling logic at the thread level of the application program are inherited. For example, inherit the exception handling logic at the thread group level of the second thread group, and inherit the exception handling logic of different threads in the application program. In this way, no matter whether the exception handling logic at the thread level is the default setting of the application itself, or the third SDK or The thread-level exception handling logic of the third plug-in will be inherited.

In order to avoid exceptions, in this embodiment, the method name of the second exception handling method is the same as the method name of the first exception handling method of the application program

In this embodiment, at least part of the exception handling logic of the second exception handling method is different from the first exception handling logic. This difference can be reflected in the fact that there is no need to transfer exception capture events between thread levels.

Optionally, the second exception method includes:

Inherited said first exception handling method;

A third exception handling method is created; wherein, the exception handling logic of the third exception handling method is different from the exception handling logic of the first exception handling method.

In this embodiment, the exception handling logic of the third exception handling method is different from the exception handling logic of the first exception handling method. For example, the third exception handling logic may be exception code deletion logic. For example, in a hot repair technology for repairing a bug by using a patch, after the currently downloaded patch is installed, there may be other failures of the application program, for example, the application program cannot be executed. The third exception handling method at this time may include: deleting the exception handling logic that causes the abnormal patch; in this way, the hot fix rollback function based on the patch is realized. After the patch is deleted or uninstalled, the application can at least restore to the application The original running state of the program, reducing the problem of larger application exceptions caused by hot repair technology.

The third exception handling method can be an exception handling method preset at the thread group level in the application program, or an exception handling method downloaded from a server on the network side, and the method of creating the third exception handling method There are many methods, not limited to the above methods.

In some embodiments, the exception handling logic of the second exception handling method may be completely different from the exception handling logic of the first exception handling method, then at this time, the second exception handling method may be a completely recreated exception processing logic.

Optionally, the step S120 may include: using an overriding mechanism to create the exception handling method in the first thread group.

For example, for programming languages such as java, the original exception handling method of the application program (that is, the first exception handling method, for example, the exception handling method belonging to each thread in the second thread group) can be inherited by using an overwriting mechanism. Using this overriding mechanism to create the exception handling method in the first thread group, in the java programming language, there are both subclasses and parent classes; the exception handling method created in the first thread group is equivalent to the second thread The subclass of the exception handling method in the group, after the subclass inherits the functions or attributes of the parent class, the parent class will no longer be executed, so that the coverage of the parent class is realized, so that the first type of thread group is easily realized on the one hand The construction of the inner exception handling method, on the other hand, automatically shields the execution of the exception handling method in the second thread group.

Optionally, the method may also include:

setting the attributes of the first thread group according to the attributes of the second thread group;

Setting the reference of the first thread group based on the reference of the second thread group.

In this embodiment, since the first thread group is used to replace the second thread group for exception capture, in this embodiment, for the operating system, the first thread group needs to inherit the attributes of the second thread group , the exception capture event can be successfully passed to the first thread group from the upper level, and the normal progress of exception capture can be ensured. Therefore, in this embodiment, the attribute of the second thread group will be set as the attribute of the first thread group.

The setting the reference of the first thread group according to the reference of the second thread group may include: replacing the reference to the second thread group with the reference to the first thread group. For example, to replace references to the second thread group with references to the first thread group, you could include:

The reference of the operating system to the second thread group is replaced with the reference of the first thread group, so that when the operating system finds an exception, it can notify the first thread group of the reference of the exception capture event.

For example, the replacing the reference to the second thread group with the reference to the first thread group may specifically include:

In one mode, the reference relationship to the second thread group in the operating system is deleted, and parameters such as the thread group identifier of the first thread group are added to the application relationship, thereby realizing that the operating system's reference to the second thread group is modified to be a reference to the second thread group. The reference relationship of the first thread group, so that the operating system will notify the first thread group of the exception capture event when an exception is found based on the application relationship;

In other ways, the application relationship of the operating system to the first thread group is maintained, and the reference relationship of the operating system to the first thread group is established at the same time, so that the first thread group can also ensure that the first thread group receives the exception capture transmitted by the operating system to the thread group event.

In some embodiments, the references to the second thread group can be divided into: soft references, strong references, and weak references according to the strength of the references; the reference strength of the soft references is greater than that of the strong references, and the reference strength of the strong references is greater than that of the weak references. The citation strength of the citation.

In some embodiments, if it is a soft reference or a strong reference, when the first thread group is created according to the second thread group in step S120, the soft reference and/or strong reference will be created to the second thread group as the class of the first thread group in a thread group.

In some other embodiments, if the reference of the second thread group further includes: if reference, it may be necessary to perform reference replacement, and replace the reference of the second thread group with the reference of the first thread group.

For example, if the current operating system's reference to the second thread group is a weak reference, it is also necessary to replace the operating system's reference to the second thread group with a reference to the first thread group.

The exception handling method of the first thread group may include:

Abnormal recording method, after the abnormal recording method is executed, information such as abnormal logs will be generated. The abnormal log can be analyzed by the developer of the application program or the service platform to locate the abnormal code and provide repair technologies such as hot repair;

An exception reporting method. After the exception reporting method is executed, exception information, such as the aforementioned exception log, can be sent to the service platform. The abnormality information can be sent to the service platform regularly or irregularly through the execution of the abnormality reporting method.

In some embodiments, the exception handling method may further include:

Abnormal diagnosis method, which can be used to automatically diagnose the type of abnormality,

The exception location method can be used to locate the thread and/or code that causes the exception.

The above are only examples of exception handling methods, and the specific implementation is not limited to any one of the above methods.

Optionally, the setting the attribute of the first thread group according to the attribute of the second thread group includes at least one of the following:

Setting the thread group name of the first thread group according to the thread group name of the second thread group;

Setting the thread group information included in the first thread group according to the thread information included in the second thread group;

The type of the first thread group is set according to the type of the second thread group, wherein the type includes: a foreground thread group type and/or a background thread group type.

In this embodiment, the foreground thread group type: if the thread group of this type is running, the thread group of its running status and/or running results in the foreground of the device, and the thread group of the background thread group type is executed in the background of the device. Its running status and/or running results cannot be seen in the foreground. The running status and/or running results of the thread group can be seen in the foreground, and its running status and/or running results can be seen on the display interface.

Optionally, the setting the attribute of the first thread group according to the attribute of the second thread group includes:

Using a reflection mechanism to set the attributes of the first thread group according to the attributes of the second thread group.

In this embodiment, the reflection mechanism is used to set the attributes of the second thread group to the attributes of the first thread group, so that the functions of the second thread group do not need to be changed. For example, the attribute of the second thread group is read through a reflection mechanism and assigned to the first thread group created in step S110, so that the attribute of the first thread group is the same as the attribute of the second thread group.

For example, the reflection mechanism of java can be as follows:

In the running state of a java program, for any class, you can know all the properties and methods of this class; for any object, you can call any of its methods and properties; this function of dynamically obtaining information and dynamically calling object methods It is called the reflection mechanism of java language.

Therefore, in this embodiment, if the attribute of the second thread group is set to private, when obtaining the attribute of the second thread group, you can choose to read its attribute during the running of the second thread group, for example, to the second thread group The attributes of the second thread group are read from the cache of the thread group, thereby simply realizing the purpose of assigning the attributes of the second thread group to the first thread group.

Optionally, referring to FIG. 2, the step S130 may include:

The first thread group receives an exception capture event from an operating system;

The exception catching method of the first thread group performs exception catching based on an exception catching event.

In this embodiment, the first thread group will be used to directly replace the second thread group to receive exception capture events from the operating system. In this way, the exception handling function of the first thread group is activated. In this embodiment, the first thread group directly performs Exception handling at the thread group level no longer needs to pass exception capture events between threads at the thread level, thereby avoiding problems such as incomplete exception detection or incomplete records caused by not passing exception capture events between different threads.

As shown in Figure 3, this embodiment provides an abnormality detection processing device, including:

A first creating module 110, configured to create a first thread group;

A second creating module 120, configured to create an exception handling method in the first thread group;

The replacement processing module 130 is configured to use the first thread group to replace the second thread group of the application program to perform exception handling.

In this embodiment, the first creating module 110, the second creating module 120, the replacement module and the processing module can all be program modules, which can be used to create the first thread group, create an exception handling method, and replace the first thread group. The second thread group performs exception handling and so on.

Optionally, the second creation module 120 is specifically configured to create a second exception handling method in the first thread group; set the method name of the first exception handling method of the application as the second The method name of the exception handling method; wherein, the exception handling logic of the second exception handling method is at least partially different from the exception handling logic of the first exception handling method.

Optionally, the second exception handling method includes: the inherited first exception handling method; and/or, a created third exception handling method; wherein, the exception handling logic of the third exception handling method is different from the Describe the exception handling logic of the first exception handling method.

Optionally, the second creating module 120 is specifically configured to create the exception handling method in the first thread group by using an overwriting mechanism.

Optionally, the device also includes:

An attribute module, specifically configured to set the attribute of the first thread group according to the attribute of the second thread group;

A reference replacement module, configured to set the reference of the first thread group according to the reference of the second thread group.

Optionally, the second creation module 120 may be specifically configured to perform at least one of the following:

Setting the thread group name of the first thread group according to the thread group name of the second thread group;

Setting the thread group information included in the first thread group according to the thread information included in the second thread group;

The type of the first thread group is set according to the type of the second thread group, wherein the type includes: a foreground thread group type and/or a background thread group type.

In some other embodiments, the second creating module 120 may be specifically configured to use a reflection mechanism to set the attribute of the first thread group according to the attribute of the second thread group.

In some embodiments, the alternative processing module 130 may be specifically configured for the first thread group to receive an exception capture event from an operating system; the exception capture method of the first thread group executes exception capture based on the exception capture event.

This embodiment provides an electronic device, including:

memory for information storage;

A processor, connected to the memory, configured to implement the method provided by the foregoing one or more technical solutions by executing computer-executable instructions stored in the memory.

Memory can be either volatile memory or nonvolatile memory, and can include both volatile and nonvolatile memory. Wherein, the nonvolatile memory can be a read-only memory (Read Only Memory, ROM), a programmable read-only memory (Programmable Read-Only Memory, PROM), an erasable programmable read-only memory (Erasable Programmable Read-Only Memory, EPROM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Magnetic Random Access Memory (FRAM), Flash Memory (Flash Memory), Magnetic Surface Memory, Optical Disk , or CD-ROM (Compact Disc Read-Only Memory); the magnetic surface storage can be disk storage or tape storage. The volatile memory can be Random Access Memory (RAM), which acts as an external cache. By way of illustration and not limitation, many forms of RAM are available such as Static Random Access Memory (SRAM), Synchronous Static Random Access Memory (SSRAM), Dynamic Random Access Memory Memory (Dynamic Random Access Memory, DRAM), Synchronous Dynamic Random Access Memory (Synchronous Dynamic Random Access Memory, SDRAM), Double Data Rate Synchronous Dynamic Random Access Memory (Double Data Rate Synchronous Dynamic Random Access Memory, DDRSDRAM), Enhanced Synchronous Dynamic Random Access Memory (Enhanced Synchronous Dynamic Random Access Memory, ESDRAM), Synchronous Connection Dynamic Random Access Memory (SyncLink Dynamic Random Access Memory, SLDRAM), Direct Memory Bus Random Access Memory (Direct Rambus Random Access Memory, DRRAM). The memory described by embodiments of the present invention is intended to include, but not be limited to, these and any other suitable types of memory.

The processor can be a central processing unit, a microprocessor, a digital signal processor, a programmable array or an application-specific integrated circuit, and the like.

In some embodiments, the electronic device may further include a communication interface, which may be connected to the processor, and the communication interface may include: a network interface for connecting peripheral devices to a peripheral device interface or a network. The communication interface provides an interface for information exchange between the processor and the peripheral interface module. The peripheral interface module may be a keyboard, mouse, trackball, click wheel, key, button, etc. These buttons may include, but are not limited to: a home button, volume buttons, start button, and lock button.

The processor can be connected to a memory or a communication interface through a bus interface in an electronic device such as an integrated circuit bus.

The electronic device provided in this embodiment may be various mobile or fixed devices such as a mobile phone, a tablet computer, a wearable device, a virtual reality device or an augmented reality device.

This embodiment also provides a computer storage medium, the computer storage medium stores computer-executable instructions; after the computer-executable instructions are executed, the method provided by any one of the foregoing embodiments can be performed, for example, FIG. 1 and/or FIG. 4 shows the method.

The computer storage medium can be various storage mediums such as optical discs, mobile hard disks, floppy disks, U disks, random access memories, read-only memories, etc., and can be selected as non-transient storage media.

Several specific examples are provided below in combination with any of the above-mentioned embodiments:

Example 1:

As shown in Figure 4, this example provides an anomaly detection method for an application, which may include:

When the application starts, a first thread group is created, and the newly established first thread group may be of the same type as the main thread group where the main function of the application is located;

Create a first exception handling method in the first thread group by using the override mechanism; for example, override the exception handling method of the main thread group to obtain the first exception handling method;

Adding a preset third exception handling method in the first thread group, or downloading the third exception handling method from the network server;

Using a reflection mechanism to set the attributes of the first thread group according to the attributes of the second thread group;

Utilize the second thread group to monitor the exception capture event provided by the operating system (for example, the system thread group), and perform exception handling such as thread group level exception capture when the exception capture event is monitored.

Example 2:

This example first provides descriptions of several related terms, as follows:

The thread group includes: a plurality of threads, and the threads in it can be uniformly managed.

There is a concept of thread group (ThreadGroup) in the multi-thread processing of java. ThreadGroup is to facilitate thread management, and some attributes of the thread group can be set uniformly, for example, attribute (setDaemon), set the processing method of unhandled exception, and set uniform Security policies, etc.; You can also easily obtain some information about the thread through the thread group.

Each ThreadGroup can contain a group of sub-threads and a group of sub-thread groups. In a process, the thread group exists in a tree form. Usually, the root thread group is the system thread group. Under the system (system) thread group is the main (main) thread group. By default, the first-level application's own thread group is created through the main thread group. The system thread group may notify the main thread group of the exception capture event, where the main thread group may be the aforementioned second thread group.

Java reflection mechanism:

The java reflection mechanism is in the running state. For any class, you can know all the properties and methods of this class; for any object, you can call any of its methods and properties; this dynamic acquisition of information and dynamic calling of object methods The function is called the reflection mechanism of the java language.

The JAVA reflection mechanism can be: when the program is running, it is allowed to change the program structure or variable type. This language is called a dynamic language. The reflection mechanism, which can be used in java, means that we can load, detect, and use classes that are completely unknown during compilation at runtime. In other words, a java program can load a class (class) whose name is known at runtime, learn its complete structure (but not including method definitions), and generate its object entity, or set values for its fields (fields), or invoke its method.

1. Create a new thread group, namely the aforementioned first thread group;

After the application starts, create a new thread group (ThreadGroup) object, and override the default exception capture method in the class to which the object belongs, and implement specific exception handling logic in the exception capture method.

Java provides the ThreadGroup class to control a thread group. A thread group can be created through a thread object, or it can be created by other thread groups to generate a tree structure of threads.

After creating a new thread group, the original exception catching method is overwritten to a method with custom logic through the java overriding mechanism (override). When overriding, the java application will create a new class to inherit the default exception capture method (corresponding to the aforementioned first exception handling method), and then implement the custom logic method (corresponding to the aforementioned third exception handling method) in the newly created class Exception handling method), the method name is the same as the original default exception catching method.

In the Android system, the method will be called according to the method name. In the original processing logic, when an exception occurs in the thread, the exception handling method in the thread group will be called through the method name to handle the exception. In this proposal, since the default The exception catching method is overwritten with a custom logic method, so after the exception logic occurs, the method of the custom logic will be called according to the method name to handle the exception.

Here, take the hot fix rollback as an example: the rollback processing method for the hot fix function (after the hot fix is performed on the application, if the repaired program will crash during operation, then through this method, when the application is abnormal After that, the rollback processing method for the hot repair function will be called to uninstall the hot repair patch to ensure the normal operation of the application. In this way, the hot repair function can be rolled back after the thread group captures the exception that occurs during the hot repair process. refund processing).

In some cases, the exception handling method may further include: a method of saving the exception information in the form of a log; and/or a method of uploading the exception information to the server platform.

Reuse of thread group attributes

Use the java reflection mechanism to obtain the main thread group object where the APP main thread is located. In order not to affect the original function of the thread group where the main thread is located (in java, the interaction between the thread group and the scene is based on the thread group attributes. If the original thread group attribute is not reused, the name of the thread group to which the main thread belongs will change, and other threads contained in the original thread group will be lost, etc., resulting in abnormal operation of the application), and the main thread can be obtained through the Android reflection function All attributes of the thread group to which it belongs, and assign the obtained attributes to the newly created thread group object, so as to realize the reuse of the thread group information of the main thread. The thread group information may be, for example: a thread group name, thread information included in the thread group, whether it is a background program thread group, and the like.

Thread group replacement, including: Taking the Android system as an example, because Android sets the thread group attribute of the thread as private, it is impossible to obtain the thread group object of the main thread through the normal way, and the thread group of the APP main thread is reflected by Android Function, after obtaining the thread group reference of the main thread, point it to a new thread group that has reused the information of the original thread group, so as to realize the replacement of the thread group of the main thread, so that the new thread group has a method with custom logic (such as , the exception handling method that handles the hotfix exception rollback logic), and realizes the ability to catch exceptions.

Crash exception capture and processing, including: when an APP crash event occurs, the exception information will first

Passed to the thread group where the crashed thread is located, this solution uses only the default

The thread group object that recognizes the exception handling logic is replaced by the thread group object that has the exception handling logic actually needed

The thread group object captures abnormal events and reports the abnormal information to the abnormal management platform.

Through the method of this proposal, in addition to catching the exception of the main thread, whether the exception of other threads of the application can be caught through a similar method, as long as the thread group to which the thread to be caught is replaced by this method.

The first level of exception capture event transmission is the exception capture at the thread group level, the second level is the thread level exception capture, and the exception transmission is from the first level to the second level. The current common exception capture schemes are all aimed at the second level. If there is an exception capture program that captures exceptions at the second level and does not pass the exception to other exception capture programs after catching the exception, then other exception handlers will not be able to catch it. exception, and the exception capture mechanism of this scheme is the first level, the exception capture can be completed at the first level, and the exception capture can also be passed to the second level, at this time, if there is an abnormal program at the second level, the exception capture and No exception transmission is performed, nor does it affect the exception capture of this solution.

Exception capture is achieved by replacing the thread group of threads with a custom thread group with exception capture and processing logic. There is no situation where exception captures that exist in related exception capture schemes are overridden by each other.

In the several embodiments provided in this application, it should be understood that the disclosed devices and methods may be implemented in other ways. The device embodiments described above are only illustrative. For example, the division of the units is only a logical function division. In actual implementation, there may be other division methods, such as: multiple units or components can be combined, or May be integrated into another system, or some features may be ignored, or not implemented. In addition, the coupling, or direct coupling, or communication connection between the components shown or discussed may be through some interfaces, and the indirect coupling or communication connection of devices or units may be electrical, mechanical or other forms of.

The units described above as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in one place or distributed to multiple network units; Part or all of the units can be selected according to actual needs to achieve the purpose of the solution of this embodiment.

In addition, each functional unit in each embodiment of the present invention can be integrated into one processing module, or each unit can be used as a single unit, or two or more units can be integrated into one unit; the above-mentioned integration The unit can be realized in the form of hardware or in the form of hardware plus software functional unit.

Those of ordinary skill in the art can understand that all or part of the steps for realizing the above-mentioned method embodiments can be completed by hardware related to program instructions, and the aforementioned program can be stored in a computer-readable storage medium. When the program is executed, the Including the steps of the foregoing method embodiments; and the aforementioned storage medium includes: various storage devices, read-only memory (Read-Only Memory, ROM), random access memory (Random Access Memory, RAM), magnetic disk or optical disk A medium on which program code can be stored.

The above is only a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Anyone skilled in the art can easily think of changes or substitutions within the technical scope disclosed in the present invention. Should be covered within the protection scope of the present invention. Therefore, the protection scope of the present invention should be determined by the protection scope of the claims.

In the several embodiments provided in this application, it should be understood that the disclosed devices and methods may be implemented in other ways. The device embodiments described above are only illustrative. For example, the division of the units is only a logical function division. In actual implementation, there may be other division methods, such as: multiple units or components can be combined, or May be integrated into another system, or some features may be ignored, or not implemented. In addition, the coupling, or direct coupling, or communication connection between the components shown or discussed may be through some interfaces, and the indirect coupling or communication connection of devices or units may be electrical, mechanical or other forms of.

The units described above as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in one place or distributed to multiple network units; Part or all of the units can be selected according to actual needs to achieve the purpose of the solution of this embodiment.

In addition, each functional unit in each embodiment of the present invention can be integrated into one processing module, or each unit can be used as a single unit, or two or more units can be integrated into one unit; the above-mentioned integration The unit can be realized in the form of hardware or in the form of hardware plus software functional unit.

Those of ordinary skill in the art can understand that all or part of the steps for realizing the above-mentioned method embodiments can be completed by hardware related to program instructions, and the aforementioned program can be stored in a computer-readable storage medium. When the program is executed, the Including the steps of the foregoing method embodiments; and the aforementioned storage medium includes: various storage devices, read-only memory (Read-Only Memory, ROM), random access memory (Random Access Memory, RAM), magnetic disk or optical disk A medium on which program code can be stored.

The above is only a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Anyone skilled in the art can easily think of changes or substitutions within the technical scope disclosed in the present invention. Should be covered within the protection scope of the present invention. Therefore, the protection scope of the present invention should be determined by the protection scope of the claims.

Claims (12)

1. An anomaly detection and processing method, characterized in that, comprising: Create the first thread group; creating an exception handling method within the first thread group; Using the first thread group to replace the second thread group of the application program for exception handling. 2. The method of claim 1, wherein, The creating an exception handling method in the first thread group includes: creating a second exception handling method within the first thread group; Set the method name of the first exception handling method of the application as the method name of the second exception handling method. 3. The method of claim 2, wherein, The exception handling logic of the second exception handling method is at least partially different from the exception handling logic of the first exception handling method. 4. The method of claim 2, wherein, The second exception method includes: Inherited said first exception handling method; A third exception handling method is created; wherein, the exception handling logic of the third exception handling method is different from the exception handling logic of the first exception handling method. 5. The method of claim 1, wherein, The creating an exception handling method in the first thread group includes: The exception handling method is created in the first thread group by using an overriding mechanism. 6. The method according to any one of claims 1 to 5, characterized in that, The method also includes at least one of the following: setting the attributes of the first thread group according to the attributes of the second thread group; Setting the reference of the first thread group based on the reference of the second thread group. 7. The method of claim 6, wherein, The setting the attribute of the first thread group according to the attribute of the second thread group includes at least one of the following: Setting the thread group name of the first thread group according to the thread group name of the second thread group; Setting the thread group information included in the first thread group according to the thread information included in the second thread group; The type of the first thread group is set according to the type of the second thread group, wherein the type includes: a foreground thread group type and/or a background thread group type. 8. The method of claim 6, wherein The setting the attribute of the first thread group according to the attribute of the second thread group includes: Using a reflection mechanism to set the attributes of the first thread group according to the attributes of the second thread group. 9. The method according to any one of claims 1 to 5, characterized in that, The use of the first thread group to replace the second thread group of the application program for exception handling includes: The first thread group receives an exception capture event from an operating system; The exception catching method of the first thread group performs exception catching based on an exception catching event. 10. An anomaly detection and processing device, characterized in that it comprises: The first creation module is used to create the first thread group; A second creating module, configured to create an exception handling method in the first thread group; The replacement processing module is used to use the first thread group to replace the second thread group of the application program to perform exception processing. 11. An electronic device, characterized in that it comprises: memory for information storage; A processor, connected to the memory, configured to implement the method provided by any one of claims 1 to 9 by executing computer-executable instructions stored in the memory. 12. A computer storage medium, wherein the computer storage medium stores computer-executable instructions; after the computer-executable instructions are executed, the method provided by any one of claims 1 to 9 can be implemented.