CN107741891B - Destructor methods, media, devices and computing devices of objects - Google Patents

Abstract

Embodiments of the present invention provide an object destruction method, medium, apparatus and computing device. The method for destructing the object includes: when the life cycle of the target object ends, delaying the destruction of the target object; and sending the original to the The method of the target object is forwarded to a null function pointer. The technical solution of the embodiment of the present invention makes it possible to ensure the normal operation of the program by forwarding the method sent to the object to a null function pointer even if the problem of accessing the object whose life cycle has ended occurs in the program, thus solving the problem of the program. The problem of BAD ACCESS type crash affecting users' use has been improved, and the stability of program operation has been improved.

Description

Destructor methods, media, devices and computing devices of objects

technical field

The embodiments of the present invention relate to the fields of communication and computer technology, and more particularly, the embodiments of the present invention relate to methods, media, apparatuses, and computing devices for destructing objects.

Background technique

This section is intended to provide a background or context for the embodiments of the invention that are recited in the claims. The descriptions herein are not admitted to be prior art by inclusion in this section.

In the software development industry, it is inevitable to encounter the problem of APP (Application, application) crash. Among them, BAD ACCESS type crashes account for a high proportion and are difficult to troubleshoot. BAD ACCESS type crashes are caused by programs accessing wild pointers. .

At present, there are two main solutions for BAD ACCESS type crashes in the industry: the first solution is to directly crash the APP, analyze the cause of the crash by grabbing the crash log, and then release a new APP version to solve the corresponding crash problem after repairing; The second solution is to use the hot update method, that is, to deliver the repaired code through a script file, to replace the method and call the script code at runtime, so as to achieve the purpose of repairing the problem before releasing the new APP version.

SUMMARY OF THE INVENTION

Since the first solution needs to release a new APP version to solve the corresponding crash problem, there is no effective way to avoid the BAD ACCESS type of crash before the new APP version is released, resulting in this type of crash during this period. Timely processing reduces user experience. At the same time, the crash of the BAD ACCESS type is difficult to reproduce due to the difficulty of reproducing the crash scene, which makes it very difficult to troubleshoot and repair. The acquisition of real-time information of crash scenarios is particularly important, but the existing methods of capturing real-time information through crash logs are usually not accurate enough.

The hot update method used in the second solution has certain security risks, and although the hot update technology can achieve the purpose of repairing the problem before releasing a new APP version, it still needs a problem to capture, analyze, solve and apply. The process cannot achieve the effect of solving problems in real time and preventing APP from crashing in time.

For this reason, an improved object destructing scheme is very much needed, so as to at least solve the problem that the program has a BAD ACCESS type crash and affect the use of the user, and improve the stability of the program operation.

In this context, embodiments of the present invention are intended to provide an object destructuring method, medium, apparatus, and computing device.

In a first aspect of the embodiments of the present invention, a method for destructing an object is provided, including: when the life cycle of the target object ends, delaying the destruction of the target object; During the time period of delayed destruction, the method originally sent to the target object is forwarded to a null function pointer.

In some embodiments of the present invention, based on the foregoing solution, the method further includes: judging whether each object in the program needs wild pointer protection; if it is determined that any object in the program needs wild pointer protection, then An object is marked with a mark, and the marked object is used as the target object.

In some embodiments of the present invention, based on the foregoing solution, it is determined whether each object needs to be protected against wild pointers according to the type of each object.

In some embodiments of the present invention, based on the foregoing solution, the step of judging whether each object in the program needs to be protected against wild pointers includes: replacing the method used to create the various objects with a defined new method; In the new method, it is judged whether each object needs to be protected against wild pointers.

In some embodiments of the present invention, based on the foregoing solution, the step of adding an identifier to the any object includes: adding the identifier to the any object based on a function of dynamically adding an associated object.

In some embodiments of the present invention, based on the foregoing solution, the method further includes: when it is determined to perform delayed destruction on the target object, releasing the relevant attributes referenced by the target object.

In some embodiments of the present invention, based on the foregoing solution, the step of forwarding the method originally sent to the target object to a null function pointer includes: modifying the class pointed to by the function pointer of the target object to a specified class, Wherein, the function pointer originally points to the original class of the target object; the method originally sent to the target object is intercepted based on the specified class, and forwarded to the null function pointer.

In some embodiments of the present invention, based on the foregoing solution, the step of intercepting the method originally sent to the target object based on the specified class and forwarding it to the null function pointer includes: passing a message in the specified class The forwarding function intercepts the method originally sent to the target object, and returns an object class; dynamically adds a class method to the object class, and points the pointer of the class method to an empty function.

In some embodiments of the present invention, based on the foregoing solution, the method further includes: saving the class name of the original class into the target object.

In some embodiments of the present invention, based on the foregoing solution, the method further includes: obtaining the class name of the original class stored in the target object; and according to the obtained class name, counting error data that occurs during the running of the program.

In some embodiments of the present invention, based on the foregoing solution, the method further includes: judging whether the program is switched to run in the background, and/or judging whether the number of target objects for delayed destruction reaches a predetermined number; after determining whether the program is switched to the background At runtime, and/or when it is determined that the number of target objects to be destructed in a delayed manner reaches the predetermined number, the original memory release function of the target object of deferred destructed destruction is called to destruct the target object.

In a second aspect of an embodiment of the present invention, there is provided a medium on which a program is stored, and when the program is executed by a processor, the method as described in the first aspect of the above-mentioned embodiment is implemented.

In a third aspect of the embodiments of the present invention, an apparatus for destructing an object is provided, including: a destructing unit, configured to delay the destructing of the target object when the life cycle of the target object ends; processing The unit is configured to forward the method originally sent to the target object to a null function pointer within the time period during which the target object is destructed in a delayed manner.

In some embodiments of the present invention, based on the foregoing solution, it further includes: a first judging unit for judging whether each object in the program needs to be protected against wild pointers; an adding unit for judging all objects in the first judging unit When any object in the program needs to be protected from wild pointers, an identifier is added to the any object, and the object to which the identifier is added is used as the target object.

In some embodiments of the present invention, based on the foregoing solution, the first judgment unit is configured to: according to the types of the respective objects, judge whether the respective objects need to be protected from wild pointers.

In some embodiments of the present invention, based on the foregoing solution, the first judgment unit is configured to: replace the method for creating the respective objects by a defined new method; judge the respective objects in the new method Whether the object needs wild pointer protection.

In some embodiments of the present invention, based on the foregoing solution, the adding unit is configured to: add the identifier to any of the objects based on a function of dynamically adding an associated object.

In some embodiments of the present invention, based on the foregoing solution, the destructing unit is further configured to release the relevant attributes referenced by the target object when it is determined that the target object is to be destructed in a delayed manner.

In some embodiments of the present invention, based on the foregoing solution, the processing unit includes: a modification unit, configured to modify the class pointed to by the function pointer of the target object to a specified class, wherein the function pointer originally pointed to the The original class of the target object; the interception unit is configured to intercept the method originally sent to the target object based on the specified class, and forward it to the null function pointer.

In some embodiments of the present invention, based on the foregoing solution, the intercepting unit is configured to: intercept a method originally sent to the target object through a message forwarding function in the specified class, and return an object class; The object class dynamically adds a class method and points the pointer of the class method to a null function.

In some embodiments of the present invention, based on the foregoing solution, the method further includes: a saving unit, configured to save the class name of the original class into the target object.

In some embodiments of the present invention, based on the foregoing solution, it further includes: an acquisition unit, used to acquire the class name of the original class stored in the target object; a statistics unit, used to count the program according to the acquired class name Error data that occurred during operation.

In some embodiments of the present invention, based on the foregoing solution, it further includes: a second judgment unit for judging whether the program is switched to run in the background, and/or judging whether the number of target objects to be destructed by delay reaches a predetermined number; The destructuring unit is further configured to, when the second judging unit determines that the program is switched to running in the background, and/or when it is determined that the number of target objects to be destructed in a delayed manner reaches the predetermined number, call the delayed analysis unit. The original function of releasing the memory of the target object of the construction is used to destruct the target object.

In a fourth aspect of an embodiment of the present invention, a computing device is provided, including: a processor and a memory, where the memory stores executable instructions, and the processor is configured to call the executable instructions stored in the memory to execute an example such as: The method described in the first aspect of the above embodiment.

According to the object destruction method, medium, device and computing device according to the embodiments of the present invention, since the BAD ACCESS type crash is caused by the program accessing the wild pointer, the Carry out delayed destruction, and forward the method originally sent to the target object to a null function pointer within the time period of delayed destruction of the target object, so that even if there is an object whose life cycle has ended in the program The problem of access can also be ensured by forwarding the method sent to the object to a null function pointer to ensure the normal operation of the program, which solves the problem that the program has a BAD ACCESS type crash and affects the user's use, and improves the stability of the program operation.

According to the object destructuring method, medium, device and computing device according to the embodiments of the present invention, the class name of the original class of the target object is stored in the target object, and statistics are calculated according to the class name of the original class stored in the target object The error data that occurs in the running process of the program can effectively retain the on-site information of the BAD ACCESS type crash of the program, which can facilitate the technicians to troubleshoot and repair.

Description of drawings

The above and other objects, features and advantages of exemplary embodiments of the present invention will become readily understood by reading the following detailed description with reference to the accompanying drawings. In the accompanying drawings, several embodiments of the present invention are shown by way of example and not limitation, wherein:

FIG. 1 schematically shows a flow chart of a method for destructing an object according to an embodiment of the present invention;

FIG. 2 schematically shows a flowchart of determining an object that needs wild pointer protection according to an embodiment of the present invention;

Fig. 3 shows the specific flow chart of step S12 shown in Fig. 1;

FIG. 4 schematically shows a flowchart of processing an object instance that needs wild pointer protection according to an embodiment of the present invention;

FIG. 5 schematically shows a flow chart of processing an object destructed by delay according to an embodiment of the present invention;

FIG. 6 schematically shows a schematic diagram of a processing procedure during a delayed destructuring period according to an embodiment of the present invention;

FIG. 7 schematically shows a block diagram of an object destructor according to an embodiment of the present invention.

In the drawings, the same or corresponding reference numerals denote the same or corresponding parts.

Detailed ways

The principles and spirit of the present invention will now be described with reference to several exemplary embodiments. It should be understood that these embodiments are only given for those skilled in the art to better understand and implement the present invention, but not to limit the scope of the present invention in any way. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.

As will be appreciated by those skilled in the art, embodiments of the present invention may be implemented as a system, apparatus, device, method or computer program product. Accordingly, the present disclosure may be embodied in entirely hardware, entirely software (including firmware, resident software, microcode, etc.), or a combination of hardware and software.

According to the embodiments of the present invention, an object destruction method, medium, apparatus and computing device are provided.

In this article, it should be understood that the terms "program", "application" and "application" refer to programs installed on smart devices such as mobile phones, referred to as APPs, which generally need to cooperate with the server to run. Common applications are mainly divided into two categories: one is pre-installed system applications, such as text messages, photos, memos, etc.; the other is third-party applications, such as NetEase News for information, Taobao for shopping, WeChat for social networking, etc. Wait.

The term "program crash" refers to the phenomenon that the APP exits abnormally and suddenly during operation, and the program crash will cause all the ongoing operations of the user to be interrupted.

The term "BAD ACCESS" refers to a crash caused by a program accessing a wild pointer, such as performing a release on a released object, accessing a member variable of a released object, or sending a message to it.

The term "wild pointer" means a pointer to a deleted object or an unclaimed access restricted memory area.

The term "destruction" refers to some cleanup tasks performed when an object is undone, such as freeing memory space allocated to the object, etc.

Furthermore, any number of elements in the drawings is for illustration and not limitation, and any designation is for distinction only and does not have any limiting meaning.

The principles and spirit of the present invention are explained in detail below with reference to several representative embodiments of the present invention.

SUMMARY OF THE INVENTION

The inventors found that the current solution for releasing a new APP version to solve the BAD ACCESS type crash cannot avoid the BAD ACCESS type crash before the new APP version is released, resulting in that this type of crash cannot be dealt with in time during this period, Degraded user experience. The hot update method has certain security risks, and although the hot update technology can achieve the purpose of fixing problems before releasing a new APP version, it still needs a process of problem capture, analysis, resolution and application. It cannot solve the problem in real time and prevent the APP from crashing in time.

Therefore, the embodiments of the present invention provide an improved object destructuring method, medium, apparatus and computing device, so that even if there is a problem of accessing an object whose life cycle has ended in a program, it can be sent to the The method of the object is forwarded to a null function pointer to ensure the normal operation of the program, which solves the problem that the program crashes of the BADACCESS type and affects the user's use, and improves the stability of the program operation.

Having introduced the basic principles of the present invention, various non-limiting embodiments of the present invention are described in detail below.

Application Scenario Overview

It should be noted that the following application scenarios are only shown for easy understanding of the spirit and principle of the present invention, and the embodiments of the present invention are not limited in this respect. Rather, embodiments of the present invention can be applied to any scenario where applicable.

Scenario 1: When the life cycle of an object in the program ends, the object is deferred and destructed, and if there is a method sent to the object within the time period of deferred destruction, the method is forwarded To a null function pointer, it can avoid the problem of BAD ACCESS type crash caused by accessing wild pointers in the program.

Scenario 2: For the target object of delayed destruction, the class name of the original class of the target object can be saved to the target object, and the running process of the program can be counted according to the class name of the original class saved in the target object. In this way, the on-site information of the BAD ACCESS type crash of the program can be effectively preserved, and then it is convenient for the technicians to troubleshoot and repair.

Exemplary method

The following describes an object destructuring method according to an exemplary embodiment of the present invention with reference to FIG. 1 to FIG. 6 in conjunction with the above application scenarios.

FIG. 1 schematically shows a flow chart of a method for destructing an object according to an embodiment of the present invention.

Referring to FIG. 1 , the method for destructing an object according to an embodiment of the present invention includes:

Step S10, when the life cycle of the target object ends, perform delayed destruction on the target object.

It should be noted that, in the embodiment of the present invention, the end of the life cycle of the object may mean that the function where the object is located has been called.

In addition, in the embodiment of the present invention, when it is determined that the target object is to be destructed in a delayed manner, the related properties referenced by the target object may be released.

In the embodiment of the present invention, since there are many system classes in the program, such as NSString, UIView, etc. in the ISO system are created and released very frequently, the probability of wild pointer occurrence in these instances is very low. Perform wild pointer protection. Therefore, the embodiments of the present invention provide a solution for determining a target object that needs wild pointer protection as shown in FIG. 2, which specifically includes:

Step S20, it is judged whether each object in the program needs to be protected against wild pointers.

In the embodiment of the present invention, whether each object needs to be protected against wild pointers can be determined according to the type of each object in the program. For example, for some objects of system classes, wild pointer protection is not required, while for some objects of custom classes, wild pointer protection can be performed.

In an exemplary embodiment of the present invention, step S20 may include: replacing the method for creating the respective objects with a defined new method, and judging in the new method whether wild pointer protection is required for the respective objects .

For example, for the IOS system, you can use method swizzling to replace the allocWithZone (method of creating a class instance in the IOS system) method of NSObject (a class in the IOS system), and then determine whether the object needs wild pointer protection in the new method.

Step S22, if it is determined that any object in the program needs to be protected against wild pointers, add an identifier to the any object, and use the object to which the identifier is added as the target object.

In an exemplary embodiment of the present invention, the step of adding an identifier to any object in step S22 may include: adding the identifier to the any object based on a function of dynamically adding an associated object.

For example, for the IOS system, you can use the objc_setAssociatedObject (the function for dynamically adding associated objects in the IOS system) to set an identifier for the object that needs wild pointer protection, and the identified object will enter the subsequent protection process.

Continuing to refer to FIG. 1 , the destructuring method of the object further includes:

Step S12 , forward the method originally sent to the target object to a null function pointer within the time period during which the target object is destructed in a delayed manner.

In an embodiment of the present invention, referring to FIG. 3 , step S12 includes the following steps:

Step S121: Modify the class pointed to by the function pointer of the target object to a specified class, wherein the function pointer originally pointed to the original class of the target object.

For example, for the IOS system, the function pointer (that is, the isa pointer) that the target object originally points to its original class can be modified to point to a custom class, which is a pre-defined class for processing delayed destructor objects .

Step S122, intercepting the method originally sent to the target object based on the specified class, and forwarding it to the null function pointer.

In an exemplary embodiment of the present invention, step S122 includes: intercepting a method originally sent to the target object through a message forwarding function in a specified class, and returning an object class; dynamically adding a class method to the object class, and Point the pointer of the class method to a null function.

For example, for the IOS system, you can intercept the method originally sent to the target object through a custom class, and return an object class (such as stubProxy), and then dynamically add a selector (ie, a class method) to the object class, so that the imp pointer of the selector points to An empty function that returns 0.

It should be noted that, for the objects whose life cycle has ended, the implementation of the present invention is to delay the destruction of the objects, but these objects still need to be destroyed in the end. Based on this, the present invention proposes the following end delay Destruction scheme:

In some embodiments of the present invention, it is judged whether the program is switched to run in the background, and/or whether the number of target objects to be destructed in a delayed manner reaches a predetermined number; when it is judged that the program is switched to run in the background, and/or when When it is determined that the number of target objects to be destructed in a delayed manner reaches the predetermined number, the original memory release function of the target object of deferred destructed destruction is called to destruct the target object.

Based on the foregoing solution, an embodiment of the present invention further provides the following solution: saving the class name of the original class into the target object. Acquire the class name of the original class stored in the target object; according to the obtained class name, count the error data that occurs during the running of the program.

In the embodiment of the present invention, by saving the class name of the original class of the target object into the target object, and according to the class name of the original class saved in the target object, the error data that occurs during the running of the program is counted, so that It can effectively retain the on-site information of the BAD ACCESS type crash of the program, which can facilitate the technicians to troubleshoot and repair.

Taking the IOS system as an example below, the method for destructing an object according to an embodiment of the present invention will be described in detail, which mainly includes the following four processes:

1. Referring to Figure 4, it includes the following steps:

Step S401, using method swizzling to replace the original allocWithZone method in NSObject.

Step S402, in the new method, it is judged whether the object of this type needs to be protected against wild pointers, and if so, step S403 is performed; otherwise, step S404 is performed.

In step S403, a flag is set for the object instance through objc_setAssociatedObject, and the marked object will enter the protection process later.

Step S404, calling the original allocWithZone method for processing.

The process shown in Figure 4 is to add tags to the object instances that need wild pointer protection by hooking the original allocWithZone method, so that the subsequent process can identify them.

2. Referring to Figure 5, it includes the following steps:

Step S501, for the object whose life cycle has ended, use method swizzling to replace the original dealloc method in NSObject.

Step S502, it is judged whether the object instance has a flag, and if so, step S504 is performed; otherwise, step S503 is performed.

Step S503, calling the original dealloc method to release the object instance. That is, for an object instance that does not need wild pointer protection, the object instance can be released directly through the original dealloc method.

Step S504, calling the objc_destructInstance method on the object instance marked with the flag to release the relevant attributes referenced by the instance.

Step S505, modify the isa of the object instance to the HTZombieObject class. The HTZombieObject class is a pre-defined class specially used to deal with delayed destructor objects. It can forward all methods and messages sent to this class of objects to a null function pointer.

In step S506, the original class name is saved in the instance through objc_setAssociatedObject for use in subsequent error statistics.

In step S507, it is judged whether the object to be destructed by delay reaches the upper limit, and if so, step S508 is performed; otherwise, step S509 is directly performed.

Step S508, calling ht_freeSomeMemory to release the cache, so as to add the object instance to the cache.

Step S509, adding the object instance to the cache.

3. Referring to Figure 6, it includes the following steps:

Step S601, rewrite the forwardingTargetForSelector method in the HTZombieObject to intercept all messages transmitted to the HTZombieObject through the message forwarding mechanism forwardingTargetForSelector.

Step S602, creating a stub class stubProxy.

Step S603, dynamically add a corresponding selector to the stub class, the imp of the selector points to an empty function, and the empty function returns 0. That is, the purpose of the program not to crash is achieved through a function that returns empty.

In step S604, the original class name of the object instance saved before is obtained through objc_getAssociatedObject, and error data is counted.

Step S605, return stubProxy to transfer the message to the stub class object. Furthermore, when forwardingTargetForSelector intercepts the message passed to HTZombieObject, it can transfer the message to the stub class object. Since the imp of the class method selector of the stub class object points to an empty function, it will return 0 in the end, realizing that even if it is accessed The object instance whose life cycle has ended can also ensure that the program does not crash.

4. When the program returns to the background or the object instance of the delayed destructor reaches the upper limit, the original dealloc method of the destructor object is called to release all the object instances of the delayed destructor.

It should be noted that: FIGS. 4 to 6 take the IOS system as an example to describe the destructuring method of the embodiment of the present invention in detail. It should be understood by those skilled in the art that other operating systems are also applicable to the implementation of the present invention. Example destructor method.

Exemplary Media

After introducing the method of the exemplary embodiment of the present invention, next, the medium of the exemplary embodiment of the present invention is described.

In some possible implementations, various aspects of the present invention can also be implemented as a medium having stored thereon program code for implementing the "exemplary method" described above in this specification when the program code is executed by a processor of a device. The steps in the destructor method of an object according to various exemplary embodiments of the present invention described in the "" section.

Specifically, when the processor of the device executes the program code, it is configured to implement the following steps: when the life cycle of the target object ends, delay the destruction of the target object; when the target object is delayed During the time period of destruction, the method originally sent to the target object is forwarded to a null function pointer.

In some embodiments of the present invention, when the processor of the device executes the program code, it is further configured to implement the following steps: judging whether each object in the program needs wild pointer protection; If the object needs to be protected from wild pointers, an identifier is added to any of the objects, and the object to which the identifier is added is used as the target object.

In some embodiments of the present invention, when the processor of the device executes the program code, it is further configured to implement the following step: according to the type of each object, determine whether each object needs to be protected against wild pointers.

In some embodiments of the present invention, when the processor of the device executes the program code, it is configured to implement the following steps: replace the method used to create the various objects by defining a new method; Determine whether the objects need wild pointer protection.

In some embodiments of the present invention, when the processor of the device executes the program code, it is configured to implement the following step: adding the identifier to any object based on a function of dynamically adding an associated object.

In some embodiments of the present invention, when the processor of the device executes the program code, it is further configured to implement the following step: when it is determined that the target object is to be destructed in a delayed manner, release the related reference of the target object. Attributes.

In some embodiments of the present invention, when the processor of the device executes the program code, it is configured to implement the following steps: modify the class pointed to by the function pointer of the target object to a specified class, wherein the function pointer Originally pointing to the original class of the target object; intercepting the method originally sent to the target object based on the specified class, and forwarding to the null function pointer.

In some embodiments of the present invention, when the processor of the device executes the program code, it is configured to implement the following steps: intercept the method originally sent to the target object through the message forwarding function in the specified class, and return An object class; dynamically add a class method to the object class, and point the pointer of the class method to a null function.

In some embodiments of the present invention, when the processor of the device executes the program code, it is configured to implement the following step: saving the class name of the original class into the target object.

In some embodiments of the present invention, the processor of the device is further configured to implement the following steps when executing the program code: obtaining the class name of the original class stored in the target object; according to the obtained class name, Error data that occurs during the operation of the statistical program.

In some embodiments of the present invention, when the processor of the device executes the program code, it is further configured to implement the following steps: judging whether the program is switched to run in the background, and/or judging whether the number of target objects to be destructed in a delayed manner is A predetermined number is reached; when it is determined that the program is switched to run in the background, and/or when it is determined that the number of the target objects of the delayed destruction reaches the predetermined number, the original free memory of the target object of the delayed destruction is called. The function destructs the target object.

It should be noted that: the above-mentioned medium may be a readable signal medium or a readable storage medium. The readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus or device, or any combination of the above. More specific examples (non-exhaustive list) of readable storage media include: electrical connections with one or more wires, portable disks, hard disks, random access memory (RAM), read only memory (ROM), erasable programmable read only memory (EPROM or flash memory), optical fiber, portable compact disk read only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

A readable signal medium may include a propagated data signal in baseband or as part of a carrier wave, carrying readable program code therein. Such propagated data signals may take a variety of forms including, but not limited to, electromagnetic signals, optical signals, or any suitable combination of the foregoing. A readable signal medium can also be any readable medium other than a readable storage medium that can transmit, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.

Program code embodied on a readable medium may be transmitted using any suitable medium including, but not limited to, wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

Program code for carrying out operations of the present invention may be written in any combination of one or more programming languages, including object-oriented programming languages—such as Java, C++, etc., as well as conventional procedural Programming Language - such as the "C" language or similar programming language. The program code may execute entirely on the user computing device, partly on the user computing device and partly on a remote computing device, or entirely on the remote computing device or server. In the case of a remote computing device, the remote computing device may be connected to the user computing device through any kind of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computing device (eg, using an Internet service) provider to connect via the Internet).

Exemplary device

After introducing the medium of the exemplary embodiment of the present invention, next, the destructor of the object of the exemplary embodiment of the present invention will be described with reference to FIG. 7 .

FIG. 7 schematically shows a block diagram of an object destructor according to an embodiment of the present invention.

Referring to FIG. 7 , an object destructing apparatus 700 according to an embodiment of the present invention includes a destructing unit 702 and a processing unit 704 .

Specifically, the destructing unit 702 is configured to perform delayed destruction of the target object when the life cycle of the target object ends; the processing unit 704 is configured to perform delayed destruction of the target object within the time period of the delayed destruction of the target object, Forward the method originally sent to the target object to a null function pointer.

In some embodiments of the present invention, based on the foregoing solution, it further includes: a first judging unit 706 for judging whether each object in the program needs to be protected from wild pointers; an adding unit 708 for judging in the first judging unit 706 When it is determined that any object in the program needs to be protected from wild pointers, add an identifier to the any object, and use the object to which the identifier is added as the target object.

In some embodiments of the present invention, based on the foregoing solution, the first judgment unit 706 is configured to: according to the type of each object, determine whether each object needs to be protected from wild pointers.

In some embodiments of the present invention, based on the foregoing solution, the first judgment unit 706 is configured to: replace the method for creating the respective objects by a defined new method; judge the Whether each object needs wild pointer protection.

In some embodiments of the present invention, based on the foregoing solution, the adding unit 708 is configured to: add the identifier to the any object based on a function of dynamically adding an associated object.

In some embodiments of the present invention, based on the foregoing solution, the destructing unit 702 is further configured to release the relevant attributes referenced by the target object when it is determined that the target object is to be destructed in a delayed manner.

In some embodiments of the present invention, based on the foregoing solution, the processing unit 704 includes: a modification unit 7042, configured to modify the class pointed to by the function pointer of the target object to a specified class, wherein the function pointer originally Pointing to the original class of the target object; the intercepting unit 7044 is configured to intercept the method originally sent to the target object based on the specified class, and forward it to the null function pointer.

In some embodiments of the present invention, based on the foregoing solution, the intercepting unit 7044 is configured to: intercept the method originally sent to the target object through the message forwarding function in the specified class, and return an object class; The class method is dynamically added to the object class, and the pointer of the class method points to a null function.

In some embodiments of the present invention, based on the foregoing solution, the method further includes: a saving unit 710, configured to save the class name of the original class into the target object.

In some embodiments of the present invention, based on the foregoing solution, the following further includes: an obtaining unit 712, configured to obtain the class name of the original class stored in the target object; a statistics unit, configured to collect statistics according to the obtained class name Error data that occurs while the program is running.

In some embodiments of the present invention, based on the foregoing solution, it further includes: a second judgment unit 714 for judging whether the program is switched to run in the background, and/or judging whether the number of target objects for delayed destructuring reaches a predetermined number; The destructing unit 702 is further configured to, when the second judging unit determines that the program is switched to run in the background, and/or when it is determined that the number of target objects to be destructed in a delayed manner reaches the predetermined number, call the delay. The original function of releasing memory of the target object to be destructed at the time of destructing destructs the target object.

Exemplary Computing Device

After introducing the method, medium and apparatus of the exemplary embodiments of the present invention, next, a computing device according to another exemplary embodiment of the present invention is introduced.

As will be appreciated by one skilled in the art, various aspects of the present invention may be implemented as a system, method or program product. Therefore, various aspects of the present invention can be embodied in the following forms: a complete hardware implementation, a complete software implementation (including firmware, microcode, etc.), or a combination of hardware and software aspects, which may be collectively referred to herein as implementations "circuit", "module" or "system".

In some possible implementations, a computing device according to an embodiment of the present invention may include at least one processor, and at least one memory. Wherein, the memory stores program codes that, when executed by the processor, cause the processor to perform various exemplary embodiments according to the present invention described in the above-mentioned "Exemplary Methods" section of this specification The steps in the destructor of the object. For example, the processor may execute step S10 as shown in FIG. 1 , when the life cycle of the target object ends, delay the destruction of the target object; in step S12 , delay the target object During the time period of destruction, the method originally sent to the target object is forwarded to a null function pointer. As another example, the processor may also perform the steps shown in FIGS. 2 to 6 .

It should be noted that although several units or sub-units of the object's destructor are mentioned in the above detailed description, this division is merely exemplary and not mandatory. Indeed, according to embodiments of the present invention, the features and functions of two or more modules or units described above may be embodied in one module or unit. Conversely, the features and functions of one module or unit described above may be further divided into multiple modules or units to be embodied.

Furthermore, although the operations of the methods of the present invention are depicted in the figures in a particular order, this does not require or imply that the operations must be performed in the particular order, or that all illustrated operations must be performed to achieve desirable results. Additionally or alternatively, certain steps may be omitted, multiple steps may be combined to be performed as one step, and/or one step may be decomposed into multiple steps to be performed.

While the spirit and principles of the present invention have been described with reference to a number of specific embodiments, it should be understood that the invention is not limited to the specific embodiments disclosed, nor does the division of aspects imply that features of these aspects cannot be combined to perform Benefit, this division is only for convenience of presentation. The invention is intended to cover various modifications and equivalent arrangements included within the spirit and scope of the appended claims.

Claims (18)

1. A method of deconstruction of an object, comprising:

when the life cycle of a target object is finished, carrying out time delay analysis on the target object;

within the time period of performing delay analysis on the target object, forwarding the method originally sent to the target object to a null function pointer;

judging whether the program is switched to a background to run or not and judging whether the number of the target objects subjected to time delay analysis reaches a preset number or not;

when the program is judged to be switched to the background operation and the quantity of the target objects subjected to the delayed destruct is judged to reach the preset quantity, the original function of releasing the memory of the target objects subjected to the delayed destruct is called to destruct the target objects;

the step of forwarding the method originally sent to the target object to a null function pointer includes:

modifying the class pointed by the function pointer of the target object into a designated class, and storing the class name of the original class of the target object into the target object; wherein the function pointer originally points to an original class of the target object;

and intercepting a method originally sent to the target object based on the specified class, and forwarding the method to the null function pointer.

2. The method of claim 1, further comprising:

judging whether each object in the program needs to perform wild pointer protection;

and if any object in the program needs to be protected by the wild pointer, adding an identifier to the any object, and taking the object added with the identifier as the target object.

3. The method according to claim 2, wherein whether the respective object needs to be protected by a wild pointer is determined according to the type of the respective object.

4. The method of claim 2, wherein the step of determining whether each object in the program requires wild pointer protection comprises:

replacing the method for creating the respective object by the defined new method;

and judging whether each object needs to carry out wild pointer protection or not in the new method.

5. The method of claim 2, wherein the step of adding an identification to the any object comprises:

adding the identification to the any object based on a function that dynamically adds the associated object.

6. The method of claim 1, further comprising:

and releasing the related attribute referenced by the target object when determining to perform time-delay destruct on the target object.

7. The method of claim 1, wherein intercepting the method originally sent to the target object based on the specified class and forwarding to the null function pointer comprises:

intercepting a method originally sent to the target object through a message forwarding function in the specified class, and returning to an object class;

and dynamically adding a class method to the object class, and pointing a pointer of the class method to a null function.

8. The method of claim 1, further comprising:

acquiring the class name of the original class stored in the target object;

and according to the acquired class name, counting error data generated in the running process of the program.

9. A medium having stored thereon a program which, when executed by a processor, carries out the method of any one of claims 1 to 8.

10. A destructuring device of a subject, comprising:

the destructor is used for performing delayed destructor on the target object when the life cycle of the target object is finished;

the processing unit is used for forwarding the method originally sent to the target object to a null function pointer within a time period for performing delay analysis on the target object;

the second judgment unit is used for judging whether the program is switched to the background operation or not and judging whether the number of the target objects of the delay analysis structure reaches a preset number or not;

when the program is judged to be switched to the background operation and the quantity of the target objects subjected to the delayed destruct is judged to reach the preset quantity, the original function of releasing the memory of the target objects subjected to the delayed destruct is called to destruct the target objects;

wherein, the processing unit includes:

the modification unit is used for modifying the class pointed by the function pointer of the target object into a specified class and storing the class name of the original class of the target object into the target object; wherein the function pointer originally points to an original class of the target object;

and the intercepting unit is used for intercepting the method originally sent to the target object based on the specified class and forwarding the method to the null function pointer.

11. The apparatus of claim 10, further comprising:

the first judgment unit is used for judging whether each object in the program needs to carry out wild pointer protection or not;

and an adding unit, configured to add an identifier to any object in the program when the first determining unit determines that the object needs to perform wild pointer protection, and take the object to which the identifier is added as the target object.

12. The apparatus of claim 11, wherein the first determining unit is configured to: and judging whether each object needs to carry out wild pointer protection or not according to the type of each object.

13. The apparatus of claim 11, wherein the first determining unit is configured to:

replacing the method for creating the respective object by the defined new method;

and judging whether each object needs to carry out wild pointer protection or not in the new method.

14. The apparatus of claim 11, wherein the adding unit is configured to: adding the identification to the any object based on a function that dynamically adds the associated object.

15. The apparatus of claim 10, the deconstruction unit to further: and releasing the related attribute referenced by the target object when determining to perform time-delay destruct on the target object.

16. The apparatus of claim 10, wherein the intercepting unit is configured to:

intercepting a method originally sent to the target object through a message forwarding function in the specified class, and returning to an object class;

and dynamically adding a class method to the object class, and pointing a pointer of the class method to a null function.

17. The apparatus of claim 10, further comprising:

the acquisition unit is used for acquiring the class name of the original class stored in the target object;

and the counting unit is used for counting error data generated in the running process of the program according to the acquired class name.

18. A computing device, comprising: a processor and a memory, the memory storing executable instructions, the processor to invoke the memory-stored executable instructions to perform the method of any of claims 1 to 8.

Images