iOS autorelease pool blocks

Question

I was reading the documentation from apple about memory management when I got to autorelease pool blocks and something got me thinking.

 Any object sent an autorelease message inside the autorelease pool block is  
 released at the end of the block.

I am not sure I fully understand this. Any object created inside an autorelease pool block gets released at the end of the block anyway because that is it's life span. Why would you need to call autorelease to the object when it is going to get released anyway when it reaches the end of the block?

To be clearer, I will give an example, of what I am thinking:

   @autoreleasepool {

    MyObject *obj = [[MyObject alloc] init]; // no autorelease call here

    /* use the object*/
   //....
   // in the end it should get deallocated because it's lifespan ends, right?
   // so why do we need to call autorelease then?!
  }

PS: Please don't tell me that because of ARC we don't need to do some things because ARC takes care of them. I am fully aware of that, but I want to leave ARC aside for just a few moments to understand the mechanism of memory management.

Eyebolt

Answer 1

Autorelease just removes a retain count from the object it does not "free" the memory immediately like in c. When the autorelease pool ends all auto released objects with a count of 0 will have their memory freed up.

Sometimes you create a lot of objects. An example would be a loop that is creating new strings every time it iterates and adds new data to the string. You may not need the previous versions of the string and will want to free up memory used by those. You can accomplish this by explicitly using the autorelease pool instead of waiting for it to be done naturally.

//Note: answers are psudocode

//Non Arc Env
@autoreleasepool 
{

    MyObject *obj = [[MyObject alloc] init]; // no autorelease call here
    //Since MyObject is never released its a leak even when the pool exits

}
//Non Arc Env
@autoreleasepool 
{

    MyObject *obj = [[[MyObject alloc] init] autorelease]; 
    //Memory is freed once the block ends

}
// Arc Env
@autoreleasepool 
{

    MyObject *obj = [[MyObject alloc] init]; 
    //No need to do anything once the obj variable is out of scope there are no strong pointers so the memory will free

}

// Arc Env
MyObject *obj //strong pointer from elsewhere in scope
@autoreleasepool 
{

    obj = [[MyObject alloc] init]; 
    //Not freed still has a strong pointer 

}

Donate

so how is this answering my question? I provided a simple example only to avoid answers like this that don't have much to do with the question. I also added comments to the small example. – Eyebolt

Typically you only use autorelease pools in a function where there is high memory usage and you need it freed sooner then normal. The paragraph was intended to add context. – Donate

Ok, so on a non ARC env, `` MyObject *obj = [[MyObject alloc] init];`` inside an autorelease pool would be a memory leak but on an ARC env, the compiler adds automatically a release call for the object or why it isn't a memory leak anymore? – Eyebolt

Exactly, The strong pointer was on the function level so once the function exits there are no strong pointers so the object is freed. If there was a strong pointer in the class that pointed to it it would not be freed because the class still exists and therefore it has a strong pointer still. In ARC the compiler adds autorelease for you! – Donate

+1, thanks for clearing my thoughts and sorry for judging your comment too early. All te best :) – Eyebolt

No problem glad I could help. This stuff was pretty confusing coming from the c++ world and even more so once ARC was thrown in the mix. – Donate

"Autorelease just removes a retain count from the object it does not "free" the memory immediately like in c." No. autorelease simply adds an object to the autorelease pool. "When the autorelease pool ends all auto released objects with a count of 0 will have their memory freed up." No, when the autorelease pool ends it releases all objects in the pool. A release anywhere (whether by the autorelease pool or elsewhere) may cause the object to be deallocated if the retain count before the release was 1. – Dail

This answer needs to be modified to fix the errors that @Dail mentioned. – Fann

I used casual language to express an idea to someone that had already read the documentation and did not understand. Regurgitating the technical explanation didn't seem like the best approach. There is no need to modify the original post. Calling autorelease on an object has the end result of decrementing the retain count on an object. If the retain count reaches 0 the object is deallocated. – Donate

Answer 2

(Mostly just giving some additional background; @Kibitz503 is getting you to the right answer.)

@autoreleasepool {

  MyObject *obj = [[MyObject alloc] init]; // no autorelease call here

  /* use the object*/
  //....
  // in the end it should get deallocated because it's lifespan ends, right?
  // so why do we need to call autorelease then?!
}

PS: Please don't tell me that because of ARC we don't need to do some things because ARC takes care of them. I am fully aware of that, but I want to leave ARC aside for just a few moments to understand the mechanism of memory management.

OK, let's not consider ARC. In the above, without ARC, obj would not be deallocated. Only because ARC adds additional release calls does possibly get deallocated (given your example, we actually have no idea since we don't know what happens in use the object).

As @Kibitz503 explains, "release" does not mean "deallocate." At the end of the block, the autorelease pool drains, which means any pending autorelease calls are sent as release at the end of the block. If that leads to the object reaching a 0 retain count, then it is deallocated.

But whether the above is in a block or not, without ARC it is a leak.

Repugnance

Good clarification about the leak. It is a leak with or without the autorelease pool wrapped around it! – Donate

Does this mean that if I use ARC and release an object from somewhere outside the @autoreleasepool{} the object still exists until the end of the @autoreleasepool block? – Sosthenna

It depends on the code. At the end of the autoreleasepool block, all pending autoreleases created in that block are sent. I don't know what "release an object" means in your example. You probably want to put together a specific code example and post a new question. – Repugnance

Answer 3

Autorelease pools defer release of the object till the end of the pool which avoids the possibility of it being released before it reaches the end. So basically, it is to make sure the object will not be released before the end of the pool.

Alvita