Autoreleasepool
Autoreleasepool： 自动释放池，
在ARC中，我们通常通过如下形式使用autoreleasepool：
@autoreleasepool {
// do your code
}
实际上，编译器会将上面的代码转换为：
objc_autoreleasePoolPush();
// do your code
objc_autoreleasePoolPop();
相当于把autorelease的{}内执行的代码前后加上这两句
在iOS中，除了需要手动retain，release（现在已经交给了ARC自动生成）外，我们还可以将对象扔到自动释放池中，由自动释放池来自动管理这些对象。我们可以这样使用autoreleasepool：
int main(int argc, char * argv[]) {
@autoreleasepool {
NSString *str = [NSString stringWithFormat:@"%d", 123];
}
}
clang后可以得到：
int main(int argc, char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
NSString *str = ((NSString * _Nonnull (*)(id, SEL, NSString * _Nonnull, ...))(void *)objc_msgSend)((id)objc_getClass("NSString"), sel_registerName("stringWithFormat:"), (NSString *)&__NSConstantStringImpl__var_folders_8k_3pbszhls2czcmz0w335cvc0w0000gn_T_main_1a8fc0_mi_1, 123);
}
}
会发现，@autoreleasepool被改写为了__AtAutoreleasePool __autoreleasepool这样一个对象。在clang的代码里__AtAutoreleasePool的定义为：
struct __AtAutoreleasePool {
__AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
void * atautoreleasepoolobj;
};
因此，关于@autoreleasepool的代码可以被改写为开篇说的那样：
objc_autoreleasePoolPush();
// Do your code
objc_autoreleasePoolPop(atautoreleasepoolobj);
置于@autoreleasepool的{}中的代码实际上是被一个push和pop操作所包裹。当push时，会找到一个hotpage，并在page中第一个对象压栈之前先压栈一个本次autorelease的界限标识POOL_BOUNDARY地址。在{}中的所有的autorelease对象都会放到这个page中。当pop时，会把本次存到page中的对象出栈，做release操作，直到把本次存储的界限标识POOL_BOUNDARY出栈时结束。这就是一次autoreleasepool的实现原理。
objc_autoreleasePoolPush()
我们先看下runtime中objc_autoreleasePoolPush()的内部逻辑：
void *
objc_autoreleasePoolPush(void)
{
return AutoreleasePoolPage::push();
}
static inline void *push()
{
id *dest;
if (DebugPoolAllocation) {
// Each autorelease pool starts on a new pool page.
dest = autoreleaseNewPage(POOL_BOUNDARY);
} else {
dest = autoreleaseFast(POOL_BOUNDARY);
}
assert(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
return dest;
}
static inline id *autoreleaseFast(id obj)
{
AutoreleasePoolPage *page = hotPage();
if (page && !page->full()) {
return page->add(obj);
} else if (page) {
return autoreleaseFullPage(obj, page);
} else {
return autoreleaseNoPage(obj);
}
}
可以看到，当objc_autoreleasePoolPush()时，最终会调用到autoreleaseFast， 在autoreleaseFast中，会首先取出当前线程的hotPage，根据当前hotPage`的三种状态：
-
hot page存在且未满，调用page->add(obj) -
hot page存在但已满， 调用autoreleaseFullPage(obj, page)创建新的page，并设置成hot page。 -
hot page 不存在，调用autoreleaseNoPage(obj)创建新的page，并设置成hot page。
AutoreleasePoolPage
AutoreleasePoolPage在runtime中的定义如下：
class AutoreleasePoolPage
{
magic_t const magic; // 魔数，用于自身的完整性校验 16字节
id *next; // 指向autorelePool page中的下一个可用位置 8字节
pthread_t const thread; // 和autorelePool page中相关的线程 8字节
AutoreleasePoolPage * const parent; // autoreleasPool page双向链表的前向指针 8字节
AutoreleasePoolPage *child; // autoreleasPool page双向链表的后向指针 8字节
uint32_t const depth; // 当前autoreleasPool page在双向链表中的位置（深度） 4字节
uint32_t hiwat; // high water mark. 最高水位，可用近似理解为autoreleasPool page双向链表中的元素个数 4字节
// SIZE-sizeof(*this) bytes of contents follow
}
每个AutoreleasePoolPage的大小为一个SIZE，即内存管理中一个页的大小。这在Mac中是4KB，而在iOS中，这里没有相关代码，估计差不多。
由源码可用看出，在AutoreleasePoolPage 类中共有7个成员属性，大小为56Bytes，按照一个Page是4KB(4096字节)计算，显然还有4040字节没有用。剩下的空间用来存放autorelease对象的地址。
所有的AutoreleasePoolPage对象通过双向链表的形式连接在一起。
这个结合起来的双向链表就是我们所一直说的
AutoreleasePool
在图中也可以看出，单个的
AutoreleasePoolPage是以栈的形式存储的。
当加入到
autoreleasepool中的元素太多时，一个AutoreleasePoolPage就不够用的了。这时候我们需要新创建一个AutoreleasePoolPage ，多个AutoreleasePoolPage之间通过双向链表的形式串起来。成员parent和child就是用来构造双向链表的。
图中的一个begin()就是对应objc_autoreleasePoolPush()找到hotpage的开始page->add(obj)操作，依次入栈obj。
hotPage
hotPage是autoreleasePage链表中正在使用的autoreleasePage节点。实质上是指向autoreleasepage的指针，并存储于线程的TSD(线程私有数据：Thread-specific Data)中：
static inline AutoreleasePoolPage *hotPage()
{
AutoreleasePoolPage *result = (AutoreleasePoolPage *)
tls_get_direct(key);
if ((id *)result == EMPTY_POOL_PLACEHOLDER) return nil;
if (result) result->fastcheck();
return result;
}
static inline void *tls_get_direct(tls_key_t k)
{
ASSERT(is_valid_direct_key(k));
if (_pthread_has_direct_tsd()) {
return _pthread_getspecific_direct(k);
} else {
return pthread_getspecific(k);
}
}
从这段代码可以看出，
autoreleasepool是和线程绑定的，一个线程会对应一个autoreleasepool，这个绑定和对应主要是runloop中的autoreleasepool，因为在runloop的run的过程中底层逻辑会去创建和销毁一个autoreleasepool。而我们也可以自己在需要的时候手动去创建自己的autoreleasepool。而autoreleasepool虽然叫做自动释放池，其实质上是多个autoreleasepoolpage组成的双向链表。
在介绍runloop的时候，我们也曾提到过，runloop和线程也是一一对应的，并且在当前线程的runloop指针，也会存储到线程的TSD中。这是runtime对于TSD的一个应用。
我们应该想到的runloop和autoreleasepool的关系。
从其他地方看到，比如在gunstep的NSThread和NSRunLoop伪代码逻辑里我们可以看到：
// 子线程的runloop去run起来的最终会调到这里
- (BOOL) runMode: (NSString*)mode beforeDate: (NSDate*)date
{
NSAutoreleasePool *arp = [NSAutoreleasePool new];
NSString *savedMode = _currentMode;
GSRunLoopCtxt *context;
NSDate *d;
NSAssert(mode != nil, NSInvalidArgumentException);
/* Process any pending notifications.
*/
GSPrivateNotifyASAP(mode);
/* And process any performers scheduled in the loop (eg something from
* another thread.
*/
_currentMode = mode;
context = NSMapGet(_contextMap, mode);
[self _checkPerformers: context];
_currentMode = savedMode;
/* Find out how long we can wait before first limit date.
* If there are no input sources or timers, return immediately.
*/
d = [self limitDateForMode: mode];
if (nil == d)
{
[arp drain];
return NO;
}
/* Use the earlier of the two dates we have (nil date is like distant past).
*/
if (nil == date)
{
[self acceptInputForMode: mode beforeDate: nil];
}
else
{
/* Retain the date in case the firing of a timer (or some other event)
* releases it.
*/
d = [[d earlierDate: date] copy];
[self acceptInputForMode: mode beforeDate: d];
RELEASE(d);
}
[arp drain];
return YES;
}
这里也能看到
autoreleasepool是和线程绑定的现象，（因为runloop和线程绑定的）。可以看到线程中的runloop在每次run循环执行任务的时候会创建一个autoreleasepool对象，在线程里有autoreleas的对象需要add(obj)的时候就去按照上面提到的hotpage的逻辑，向autoreleasepage里压栈autoreleas的对象，在一次run循环结束的时候，也销毁了当前创建的autoreleasepool对象。
iOS在
主线程的Runloop中的Observer里对主线程的Autoreleasepool对象做了操作。
1.如果Observer监听了kCFRunLoopEntry事件:
会在这个监听里调用objc_autoreleasePoolPush()
2.如果Observer监听的是kCFRunLoopBeforeWaiting事件，会调用先objc_autoreleasePoolPop()然后再调用objc_autoreleasePoolPush()
3.如果Observer监听的是kCFRunLoopBeforeExit事件:
只调用objc_autoreleasePoolPop()
objc_autoreleasePoolPop()
当需要pop autorelease pool时，则会调用objc_autoreleasePoolPop() ：
static inline void pop(void *token)
{
AutoreleasePoolPage *page;
id *stop;
if (token == (void*)EMPTY_POOL_PLACEHOLDER) {
// Popping the top-level placeholder pool.
if (hotPage()) {
// Pool was used. Pop its contents normally.
// Pool pages remain allocated for re-use as usual.
pop(coldPage()->begin());
} else {
// Pool was never used. Clear the placeholder.
setHotPage(nil);
}
return;
}
page = pageForPointer(token);
stop = (id *)token;
if (*stop != POOL_BOUNDARY) {
if (stop == page->begin() && !page->parent) {
// Start of coldest page may correctly not be POOL_BOUNDARY:
// 1. top-level pool is popped, leaving the cold page in place
// 2. an object is autoreleased with no pool
} else {
// 这是为了兼容旧的SDK，看来在新的SDK里面，token 可能的取值只有两个:POOL_BOUNDARY, page->begin() && !page->parent
// Error. For bincompat purposes this is not
// fatal in executables built with old SDKs.
return badPop(token);
}
}
// 对page中的object做objc_release操作，一直到stop
page->releaseUntil(stop);
// memory: delete empty children 删除多余的child，节约内存
if (page->child) {
// hysteresis: keep one empty child if page is more than half full
if (page->lessThanHalfFull()) {
page->child->kill();
}
else if (page->child->child) {
page->child->child->kill();
}
}
}
在objc_autoreleasePoolPop()中，会根据传入的token，调用page->releaseUntil(stop) 方法，对每一个存储于page上的object调用objc_release(obj)方法。
之后，还会根据当前page的状态：page->lessThanHalfFull()或其他，来决定其child的处理方式：
1.如果当前pag存储的object已经不满半页，则讲page的child释放
2.如果当前page存储的object仍满半页，则保留一个空的child，并且将空child之后的所有child都释放掉。
何时需要autoreleasePool
以上就是autoreleasepool流程的内容。那么在ARC的环境下，我们何时需要用@autoreleasepool呢？
一般的，有下面两种情况：
- 创建子线程。当我们创建子线程的时候，需要将子线程的runloop用@autoreleasepool包裹起来，进而达到自动释放内存的效果。因为系统并不会为子线程自动包裹一个@autoreleasepool(除非run起来线程的runloop，这种情况就等同于主线程的自动释放内存处理)，这样加入到autoreleasepage中的元素就得不到释放。
- 在大循环中创建
autorelease对象。当我们在一个循环中创建autorelease对象(不是用alloc创建的对象，见下方补充)，该对象会加入到autoreleasepage中，而这个page中的对象，会等到外部池子结束才会释放。在主线程的runloop中，会将所有的对象的释放权都交给了RunLoop的释放池，而RunLoop的释放池会等待这个事件处理之后才会释放，因此就会使对象无法及时释放，堆积在内存造成内存泄露。
for (int i = 0; i < 1000000; i++) {
NSString *str = [NSString stringWithFormat:@"hello world -%d", i];
}
[NSString stringWithFormat:@"hello world -%d", i]方法创建的对象会加入到自动释放池里，对象的释放权交给了RunLoop 的释放池RunLoop 的释放池会等待Runloop即将进入睡眠或者即将退出的时候释放一次-
for循环中线程一直在做事情，Runloop不会进入睡眠,而RunLoop的释放池会等待这个事件处理之后才会释放，因此就会使对象无法及时释放，堆积在内存造成内存泄露。
解决办法：
1
1.1stringWithFormat:本质上是调用了alloc + initWithFormat: + autorelease
1.2将stringWithFormat:方法换成了alloc + initWithFormat:
1.3这样做问题就解决了：内存几乎没有变化
1.4(因为对象归当前的局部调用者str所有，在出了for循环每次的大括号{}方法体的时候就被释放了)。
1.5反向验证了内存飙升确实是autorelease创建方式造成的。
for (int i = 0; i < 1000000; i++) {
NSString *str = [[NSString alloc] initWithFormat:@"hello world -%d", i];
}
2
2.1加一个局部的自动释放池autoreleasepool，
2.2主动的调用objc_autoreleasePoolPush()和objc_autoreleasePoolPop()操作
for (int i = 0; i < 1000000; i++) {
@autoreleasepool {
NSString *str = [NSString stringWithFormat:@"hello world -%d", i];
}
}
补充 ：
在ARC时代，若方法名以下列词语开头，则其返回对象归调用者所有
(意为需调用者负责释放内存，但对ARC来说，一般都是运行在大括号{}函数体里，保存在函数的栈空间里的指针变量所指向，在出了这个大括号{}函数体的时候，会被系统自动的release，没有手动release的必要）
allocnewcopy-
mutableCopy
而不使用这些词语开头的方法，如[NSDictionary dictionary]，
根据苹果官方文档，当调用[NSDictionary dictionary]时：会产生一个临时的对象。类似的，还有[NSArray array], [NSData data],[NSString stringWithFormat:]...。
关于这种形式生成的变量，则表示方法所返回的对象并不归调用者所有。在这种情况下，返回的对象会自动释放。
其实我们可以理解为：当调用dictionary形式生成对象时，NSDictionary对象的引用计数管理，就不需要用户参与了（这在MRC时代有很大的区别，但是对于ARC来说，其实和alloc形式没有太大的区别了）。用[NSDictionary dictionary]其实相当于代码
[[NSDictionary alloc] init] autorelease];
这里会将NSDictionary对象交给了autorelease pool来管理。