This chapter is from the book
This chapter is from the book
This chapter is from the book
Memory Management
If heap memory were infinite, we could create all the objects we needed and have them exist for the entire run of the application. But an application gets only so much heap memory, and memory on an iOS device is especially limited. So it is important to destroy objects that are no longer needed to free up and reuse heap memory. On the other hand, it is critical not to destroy objects that are still needed.
The idea of object ownership helps us determine whether an object should be destroyed.
An object with no owners should be destroyed. An ownerless object cannot be sent messages and is isolated and useless to the application. Keeping it around wastes precious memory. This is called a memory leak.
An object with at least one owner must not be destroyed. If an object is destroyed but another object or method still has a pointer to it (or, more accurately, a pointer to where it used to live), then you have a very dangerous situation: sending a message to an object that no longer exists will crash your application. This is called premature deallocation.
Using ARC for memory management
The good news is that you don’t need to keep track of who owns whom and what pointers still exist. Instead, your application’s memory management is handled for you by automatic reference counting, or ARC.
In both projects you’ve built in Xcode so far, you’ve made sure to Use Automatic Reference Counting when creating the project (Figure 3.4). This won’t change; all of your projects in this book will use ARC for managing your application’s memory.
)
Figure 3.4 Naming a new project
(If the Use Automatic Reference Counting box in Figure 3.4 was unchecked, the application would use manual reference counting instead, which was the only type of memory management available before iOS 5. For more information about manual reference counting and retain and release messages, see the For the More Curious section at the end of this chapter.)
ARC can be relied on to manage your application’s memory automatically for the most part, but it’s important to understand the concepts behind it to know how to step in when you need to. So let’s return to the idea of object ownership.
How objects lose owners
We know that an object is safe to destroy – and should be destroyed – when it no longer has any owners. So how does an object lose an owner?
A variable that points to the object is changed to point to another object.
A variable that points to the object is set to nil.
A variable that points to the object is itself destroyed.
Let’s take a look at each of these situations.
Why might a pointer change the object it points to? Imagine a BNRItem. The NSString that its itemName instance variable points to reads “Rusty Spork.” If we polished the rust off of that spork, it would become a shiny spork, and we’d want to change the itemName to point at a different NSString (Figure 3.5).
)
Figure 3.5 Changing a pointer
When the value of itemName changes from the address of the “Rusty Spork” string to the address of the “Shiny Spork” string, the “Rusty Spork” string loses an owner.
Why would you set a pointer to nil? Remember that setting a pointer to nil represents the absence of an object. For example, say you have a BNRItem that represents a television. Then, someone scratches off the television’s serial number. You would then set its serialNumber instance variable to nil. The NSString that serialNumber used to point to loses an owner.
When a pointer variable itself is destroyed, the object that the variable was pointing at loses an owner. At what point a pointer variable will get destroyed depends on whether it is a local variable or an instance variable.
Recall that instance variables live in the heap as part of an object. When an object gets destroyed, its instance variables are also destroyed, and any object that was pointed to by one of those instance variables loses an owner.
Local variables live in the method’s frame. When a method finishes executing and its frame is popped off the stack, any object that was pointed to by one of these local variables loses an owner.
There is one more important way an object can lose an owner. Recall that an object in a collection object, like an array, is owned by the collection object. When you remove an object from a mutable collection object, like an NSMutableArray, the removed object loses an owner.
[items removeObject:p]; // object pointed to by p loses an owner
Keep in mind that losing an owner doesn’t necessarily mean that the object gets destroyed; if there is still another pointer to the object somewhere, then that object will continue to exist. However, when an object loses its last owner, it means certain and appropriate death.
Because objects own other objects, which can own other objects, the destruction of a single object can set off a chain reaction of loss of ownership, object destruction, and freeing up of memory.
We have an example of this in RandomPossessions. Take another look at the object diagram of this application.
)
Figure 3.6 Objects and pointers in RandomPossessions
In main.m, after you finish printing out the array of BNRItems, you set the items variable to nil. Setting items to nil causes the array to lose its only owner, so that array is destroyed.
But it doesn’t stop there. When the NSMutableArray is destroyed, all of its pointers to BNRItems are destroyed. Once these variables are gone, no one owns any of the BNRItems, so they are all destroyed. Destroying a BNRItem destroys its instance variables, which leaves the objects pointed to by those variables unowned. So they get destroyed, too.
Let’s add some code so that we can see this destruction as it happens. NSObject implements a dealloc method, which is sent to an object when it is about to be destroyed. We can override this method in BNRItem to print something to the console when a BNRItem is destroyed. In RandomPossessions.xcodeproj, open BNRItem.m and override dealloc.
- (void)dealloc
{
NSLog(@"Destroyed: %@", self);
}
In main.m, add the following line of code.
NSLog(@"Setting items to nil..."); items = nil;
Build and run the application. After the BNRItems print out, you will see the message announcing that items is being set to nil. Then, you will see the destruction of each BNRItem logged to the console.
At the end, there are no more objects taking up memory, and only the main function remains. All this automatic clean-up and memory recycling occurs simply by setting items to nil. That’s the power of ARC.