Detecting memory leaks with instruments

Tags: Xcode original works, allow reprint, when reproduced please be sure to use hyperlinks in the form of the original source of the article, author information and this statement. Otherwise, the legal liability will be investigated. Http://dawn110110.blog.51cto.com/3049492/899283IPhone on the wood has garbage collection, dynamic application of memory to remember to release, this article summarizes the possible memory leaks in various situations, as well as detection methods. Memory leaks plainly, there is such a dynamic request for memory, but the wood has any one pointer pointing to it. For example, in C + +:

1. MyClass * foo = new MyClass;
2. foo = NULL;

Similarly, in the objective-c:

1. MyClass *foo = [[MyClass alloc] init];
2. foo = nil; //Memory leaks!

Or have a class like this:

2. @interface Foo:nsobject
4. {}
6. @end
10. @implementation Foo
12. -(ID) init
14. {
16. if (self = [super init])) {
18. nsmutablestring * string = [[Nsmutablestring alloc] initwithstring:@"leaker!!!"];
20. string = nil; //leaked out! After that, the string object will not be freed until the application exits.
22. }
24. return self;
26. }
28. -(void) Dealloc
30. {
32. [Super Dealloc];
34. }
36. @end

What happens when a memory leak occurs? A: Very small leak, nothing! The memory used when the app exits is cleared, including leaked, and the iphone app does not request shared memory, does not ripple across the system, and there is no system-wide memory leak. If there are more leaks and repeated memory leaks, the application crashes at most. However, if you want to publish to AppStore, there is a memory leak will generally be rejected by Apple .... Let's take a look at how memory is managed in the iphone. First: Wood has automatic garbage collection! Second: There are citation counts! The NSObject object has a property: Retaincount, so all objects inherit from NSObject, only a unified reference count .... Then keep in mind the following 8 things:

• 1 this retaincount = = 0, the object's Dealloc method is called and the object is freed.
• 2 Never Show Call Dealloc method
• 3 [obj retain]; obj.retaincount++ Citation Count +1
• 4 [obj release]; obj.retaincount--Reference Count-1
• 5 MyClass * obj = [[MyClass alloc] init];//obj.retaincount = 1 initial value is 1
• 6 for attributes with retain properties such as the following:

2. @interface Myclass:nsobject {
4. nsobject* foo;
6. }
8. @property (noatomic,retain) nsobject * FOO;
10. @end
14. @implementation MyClass
16. @synthesize foo;
18. ...
20. //The following two lines are the correct wording
22. Self.foo = bar; //[foo release]; foo = bar; [Foo retain]; Will send a release to the original object, send a retain to the new object
24. Self.foo = nil; //[foo release]; a release message will be sent to the object
28. //The following line is wrong
30. foo = bar;  //did not send the release to Foo did not send retain to bar, this writing is wrong.
32. ...
34. @end

Reference:

An

explanation of Apple's documentation and specific implementations

• 7 for Stringwithstring This method to create the object, a Runloop end, the object will be sent a release message, note that there are two points, one is to pay attention to understanding runloop, to avoid the end of the Runloop object is released and use the object, two is If you use the instruments tool to detect memory leaks, this use of autorelease will also be treated as memory leaks, pay attention to identify ....

• 8 for Nsmutablearray This kind, when AddObject, when the corresponding is added to the array of the object's reference count will be + 1, when the array itself is released, it will first send a release message to all objects in the array.

Instruments can be used to detect memory leaks, in a variety of tools, with leaks. Easy to use: use Xcode (4.3) to open the corresponding project, Product->profile, and choose the leaks tool. It then dynamically records where the application is running and where memory leaks occur. There are two things to be aware of: 1 for objects that are autorelease, the leak tool also sees it as a leak, knowing that it is OK. 2 Remember to open extended Detail, for each leak, you can see the call stack here, double-click on an item in the call stack, you can directly navigate to the code, easy to find errors and modifications. The situation is as follows two graphs:

This article is from the "I have become a demon" blog, please be sure to keep this source http://dawn110110.blog.51cto.com/3049492/899283

Detecting memory leaks with instruments