前言: 做为 iOS 开发者,在面试过程当中常常会碰到这样一个问题:在 ARC 环境下,autorelease 对象在何时释放?这也是 iOS 内存管理的重要知识点,本文将针对这道面试题,讲解 autorelease 和 @autoreleasepool。html
苹果在 iOS5 中引入了ARC(Automatic Reference Counting)
自动引用计数,经过LLVM
编译器和Runtime
协做来进行自动管理内存。LLVM
编译器会在编译时在合适的地方为 OC 对象插入retain
、release
和autorelease
代码,省去了在MRC(Manual Reference Counting)
手动引用计数下手动插入这些代码的工做,减轻了开发者的工做量。面试
在MRC
下,当咱们不须要一个对象的时候,要调用release
或autorelease
方法来释放它。调用release
会当即让对象的引用计数减1,若是此时对象的引用计数为0,就会当即释放该对象的内存空间。调用autorelease
会将该对象添加进自动释放池中,它会在一个恰当的时刻自动给对象调用release
,因此autorelease
至关于延迟了对象的释放。网络
官方文档数据结构
The Application Kit creates an autorelease pool on the main thread at the beginning of every cycle of the event loop, and drains it at the end, thereby releasing any autoreleased objects generated while processing an event. If you use the Application Kit, you therefore typically don’t have to create your own pools. If your application creates a lot of temporary autoreleased objects within the event loop, however, it may be beneficial to create “local” autorelease pools to help to minimize the peak memory footprint.app
以上是苹果对自动释放池的一段介绍,其意思为:在事件循环(RunLoop
)的每次循环开始时,在主线程建立一个自动释放池,并在每次循环结束时销毁,在销毁时释放自动释放池中的全部autorelease
对象。一般状况下咱们不须要手动建立自动释放池,可是若是咱们在循环中建立了不少临时的autorelease
对象,则手动建立自动释放池来管理这些对象能够很大程度地减小内存峰值。框架
MRC
下使用NSAutoreleasePool
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// Code benefitting from a local autorelease pool.
[pool release];
复制代码
ARC
下使用@autoreleasepool
@autoreleasepool {
// Code benefitting from a local autorelease pool.
}
复制代码
下面咱们先经过macOS
工程来分析@autoreleasepool
的底层原理。 macOS
工程中的main()
函数什么都没作,只是放了一个@autoreleasepool
。less
int main(int argc, const char * argv[]) {
@autoreleasepool {}
return 0;
}
复制代码
经过 Clang clang -rewrite-objc main.m
将以上代码转换为 C++ 代码。ide
struct __AtAutoreleasePool {
__AtAutoreleasePool() {
atautoreleasepoolobj = objc_autoreleasePoolPush();
}
~__AtAutoreleasePool() {
objc_autoreleasePoolPop(atautoreleasepoolobj);
}
void * atautoreleasepoolobj;
};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */
{ __AtAutoreleasePool __autoreleasepool; }
return 0;
}
复制代码
能够看到:函数
@autoreleasepool
底层是建立了一个__AtAutoreleasePool
结构体对象;__AtAutoreleasePool
结构体时会在构造函数中调用objc_autoreleasePoolPush()
函数,并返回一个atautoreleasepoolobj
(POOL_BOUNDARY
存放的内存地址,下面会讲到);__AtAutoreleasePool
结构体时会在析构函数中调用objc_autoreleasePoolPop()
函数,并将atautoreleasepoolobj
传入。下面咱们进入Runtime objc4
源码查看以上提到的两个函数的实现。工具
备注: 本文使用的是
objc4-756.2
源码进行分析。
// NSObject.mm
void * objc_autoreleasePoolPush(void)
{
return AutoreleasePoolPage::push();
}
void objc_autoreleasePoolPop(void *ctxt)
{
AutoreleasePoolPage::pop(ctxt);
}
复制代码
能够得知,objc_autoreleasePoolPush()
和objc_autoreleasePoolPop()
两个函数实际上是调用了AutoreleasePoolPage
类的两个类方法push()
和pop()
。因此@autoreleasepool
底层就是使用AutoreleasePoolPage
类来实现的。
下面咱们来看一下AutoreleasePoolPage
类的定义:
class AutoreleasePoolPage
{
# define EMPTY_POOL_PLACEHOLDER ((id*)1) // EMPTY_POOL_PLACEHOLDER:表示一个空自动释放池的占位符
# define POOL_BOUNDARY nil // POOL_BOUNDARY:哨兵对象
static pthread_key_t const key = AUTORELEASE_POOL_KEY;
static uint8_t const SCRIBBLE = 0xA3; // 用来标记已释放的对象
static size_t const SIZE = // 每一个 Page 对象占用 4096 个字节内存
#if PROTECT_AUTORELEASEPOOL // PAGE_MAX_SIZE = 4096
PAGE_MAX_SIZE; // must be muliple of vm page size
#else
PAGE_MAX_SIZE; // size and alignment, power of 2
#endif
static size_t const COUNT = SIZE / sizeof(id); // Page 的个数
magic_t const magic; // 用来校验 Page 的结构是否完整
id *next; // 指向下一个可存放 autorelease 对象地址的位置,初始化指向 begin()
pthread_t const thread; // 指向当前线程
AutoreleasePoolPage * const parent; // 指向父结点,首结点的 parent 为 nil
AutoreleasePoolPage *child; // 指向子结点,尾结点的 child 为 nil
uint32_t const depth; // Page 的深度,从 0 开始递增
uint32_t hiwat;
......
}
复制代码
整个程序运行过程当中,可能会有多个AutoreleasePoolPage
对象。从它的定义能够得知:
AutoreleasePoolPage
对象)是以栈
为结点经过双向链表
的形式组合而成;AutoreleasePoolPage
对象占用4096
字节内存,其中56
个字节用来存放它内部的成员变量,剩下的空间(4040
个字节)用来存放autorelease
对象的地址。其内存分布图以下:
下面咱们经过源码来分析push()
、pop()
以及autorelease
方法的实现。
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); // 传入 POOL_BOUNDARY 哨兵对象
}
assert(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
return dest;
}
复制代码
当建立一个自动释放池时,会调用push()
方法。push()
方法中调用了autoreleaseFast()
方法并传入了POOL_BOUNDARY
哨兵对象。
这里对POOL_BOUNDARY
作一下介绍:
POOL_BOUNDARY
的前世叫作POOL_SENTINEL
,称为哨兵对象或者边界对象;POOL_BOUNDARY
用来区分不一样的自动释放池,以解决自动释放池嵌套的问题;push()
方法将一个POOL_BOUNDARY
入栈,并返回其存放的内存地址;autorelease
对象时,将autorelease
对象的内存地址入栈,它们前面至少有一个POOL_BOUNDARY
;pop()
方法并传入一个POOL_BOUNDARY
,会从自动释放池中最后一个对象开始,依次给它们发送release
消息,直到遇到这个POOL_BOUNDARY
。下面咱们来看一下autoreleaseFast()
方法的实现:
static inline id *autoreleaseFast(id obj)
{
AutoreleasePoolPage *page = hotPage(); // 新建立的未满的 Page
if (page && !page->full()) { // 若是当前 Page 存在且未满
return page->add(obj); // 将 autorelease 对象入栈,即添加到当前 Page 中;
} else if (page) { // 若是当前 Page 存在但已满
return autoreleaseFullPage(obj, page); // 建立一个新的 Page,并将 autorelease 对象添加进去
} else { // 若是当前 Page 不存在,即还没建立过 Page
return autoreleaseNoPage(obj); // 建立第一个 Page,并将 autorelease 对象添加进去
}
}
复制代码
autoreleaseFast()
中先是调用了hotPage()
方法得到未满的Page
,从AutoreleasePoolPage
类的定义可知,每一个Page
的内存大小为4096
个字节,每当Page
满了的时候,就会建立一个新的Page
。hotPage()
方法就是用来得到这个新建立的未满的Page
。 autoreleaseFast()
在执行过程当中有三种状况:
Page
存在且未满时,经过page->add(obj)
将autorelease
对象入栈,即添加到当前Page
中;Page
存在但已满时,经过autoreleaseFullPage(obj, page)
建立一个新的Page
,并将autorelease
对象添加进去;Page
不存在,即还没建立过Page
,经过autoreleaseNoPage(obj)
建立第一个Page
,并将autorelease
对象添加进去。下面咱们来看一下以上提到的三个方法的实现:
id *add(id obj)
{
assert(!full());
unprotect();
id *ret = next; // faster than `return next-1` because of aliasing
*next++ = obj;
protect();
return ret;
}
复制代码
page->add(obj)
其实就是将autorelease
对象添加到Page
中的next
指针所指向的位置,并将next
指针指向这个对象的下一个位置,而后将该对象的位置返回。
static __attribute__((noinline))
id *autoreleaseFullPage(id obj, AutoreleasePoolPage *page)
{
// The hot page is full.
// Step to the next non-full page, adding a new page if necessary.
// Then add the object to that page.
assert(page == hotPage());
assert(page->full() || DebugPoolAllocation);
do {
if (page->child) page = page->child;
else page = new AutoreleasePoolPage(page);
} while (page->full());
setHotPage(page);
return page->add(obj);
}
复制代码
autoreleaseFullPage()
方法中经过while
循环,经过Page
的child
指针找到最后一个Page
。
Page
未满,就经过page->add(obj)
将autorelease
对象添加到最后一个Page
中;Page
已满,就建立一个新的Page
并经过page->add(obj)
将autorelease
对象添加进去,并将该Page
设置为hotPage
。static __attribute__((noinline))
id *autoreleaseNoPage(id obj)
{
// "No page" could mean no pool has been pushed
// or an empty placeholder pool has been pushed and has no contents yet
assert(!hotPage());
bool pushExtraBoundary = false;
if (haveEmptyPoolPlaceholder()) {
// We are pushing a second pool over the empty placeholder pool
// or pushing the first object into the empty placeholder pool.
// Before doing that, push a pool boundary on behalf of the pool
// that is currently represented by the empty placeholder.
pushExtraBoundary = true;
}
else if (obj != POOL_BOUNDARY && DebugMissingPools) {
// We are pushing an object with no pool in place,
// and no-pool debugging was requested by environment.
_objc_inform("MISSING POOLS: (%p) Object %p of class %s "
"autoreleased with no pool in place - "
"just leaking - break on "
"objc_autoreleaseNoPool() to debug",
pthread_self(), (void*)obj, object_getClassName(obj));
objc_autoreleaseNoPool(obj);
return nil;
}
else if (obj == POOL_BOUNDARY && !DebugPoolAllocation) {
// We are pushing a pool with no pool in place,
// and alloc-per-pool debugging was not requested.
// Install and return the empty pool placeholder.
return setEmptyPoolPlaceholder();
}
// We are pushing an object or a non-placeholder'd pool.
// Install the first page.
AutoreleasePoolPage *page = new AutoreleasePoolPage(nil);
setHotPage(page);
// Push a boundary on behalf of the previously-placeholder'd pool.
if (pushExtraBoundary) {
page->add(POOL_BOUNDARY);
}
// Push the requested object or pool.
return page->add(obj);
}
复制代码
autoreleaseNoPage()
方法中会建立第一个Page
。该方法会判断是否有空的自动释放池存在,若是没有会经过setEmptyPoolPlaceholder()
生成一个占位符,表示一个空的自动释放池。接着建立第一个Page
,设置它为hotPage
。最后将一个POOL_BOUNDARY
添加进Page
中,并返回POOL_BOUNDARY
的下一个位置。
小结: 以上就是
push
操做的实现,往自动释放池中添加一个POOL_BOUNDARY
,并返回它存放的内存地址。接着每有一个对象调用autorelease
方法,会将它的内存地址添加进自动释放池中。
static inline id autorelease(id obj)
{
assert(obj);
assert(!obj->isTaggedPointer());
id *dest __unused = autoreleaseFast(obj);
assert(!dest || dest == EMPTY_POOL_PLACEHOLDER || *dest == obj);
return obj;
}
复制代码
能够看到,调用了autorelease
方法的对象,也是经过以上解析的autoreleaseFast()
方法添加进Page
中。
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 {
// Error. For bincompat purposes this is not
// fatal in executables built with old SDKs.
return badPop(token);
}
}
if (PrintPoolHiwat) printHiwat();
page->releaseUntil(stop);
// memory: delete empty children
if (DebugPoolAllocation && page->empty()) {
// special case: delete everything during page-per-pool debugging
AutoreleasePoolPage *parent = page->parent;
page->kill();
setHotPage(parent);
} else if (DebugMissingPools && page->empty() && !page->parent) {
// special case: delete everything for pop(top)
// when debugging missing autorelease pools
page->kill();
setHotPage(nil);
}
else 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();
}
}
}
复制代码
pop()
方法的传参token
即为POOL_BOUNDARY
对应在Page
中的地址。当销毁自动释放池时,会调用pop()
方法将自动释放池中的autorelease
对象所有释放(其实是从自动释放池的中的最后一个入栈的autorelease
对象开始,依次给它们发送一条release
消息,直到遇到这个POOL_BOUNDARY
)。pop()
方法的执行过程以下:
token
是否是EMPTY_POOL_PLACEHOLDER
,是的话就清空这个自动释放池;pageForPointer(token)
拿到token
所在的Page
(自动释放池的首个Page
);page->releaseUntil(stop)
将自动释放池中的autorelease
对象所有释放,传参stop
即为POOL_BOUNDARY
的地址;Page
是否有子Page
,有的话就销毁。pop()
方法中释放autorelease
对象的过程在releaseUntil()
方法中,下面来看一下这个方法的实现:
void releaseUntil(id *stop)
{
// Not recursive: we don't want to blow out the stack
// if a thread accumulates a stupendous amount of garbage
while (this->next != stop) {
// Restart from hotPage() every time, in case -release
// autoreleased more objects
AutoreleasePoolPage *page = hotPage();
// fixme I think this `while` can be `if`, but I can't prove it
while (page->empty()) {
page = page->parent;
setHotPage(page);
}
page->unprotect();
id obj = *--page->next; // next指针是指向最后一个对象的后一个位置,因此须要先减1
memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
page->protect();
if (obj != POOL_BOUNDARY) {
objc_release(obj);
}
}
setHotPage(this);
#if DEBUG
// we expect any children to be completely empty
for (AutoreleasePoolPage *page = child; page; page = page->child) {
assert(page->empty());
}
#endif
}
复制代码
releaseUntil()
方法其实就是经过一个while
循环,从最后一个入栈的autorelease
对象开始,依次给它们发送一条release
消息,直到遇到这个POOL_BOUNDARY
。
咱们来看一下建立一个Page
的过程。AutoreleasePoolPage()
方法的参数为parentPage
,新建立的Page
的depth
加一,next
指针的初始位置指向begin
,将新建立的Page
的parent
指针指向parentPage
。将parentPage
的child
指针指向本身,这就造成了双向链表
的结构。
AutoreleasePoolPage(AutoreleasePoolPage *newParent)
: magic(), next(begin()), thread(pthread_self()),
parent(newParent), child(nil),
depth(parent ? 1+parent->depth : 0),
hiwat(parent ? parent->hiwat : 0)
{
if (parent) {
parent->check();
assert(!parent->child);
parent->unprotect();
parent->child = this;
parent->protect();
}
protect();
}
复制代码
下面再来看一下begin
、end
、empty
、full
这些方法的实现。
begin
的地址为:Page
本身的地址+Page
对象的大小56
个字节;end
的地址为:Page
本身的地址+4096
个字节;empty
判断Page
是否为空的条件是next
地址是否是等于begin
;full
判断Page
是否已满的条件是next
地址是否是等于end
(栈顶)。id * begin() {
return (id *) ((uint8_t *)this+sizeof(*this));
}
id * end() {
return (id *) ((uint8_t *)this+SIZE);
}
bool empty() {
return next == begin();
}
bool full() {
return next == end();
}
复制代码
小结:
push
操做是往自动释放池中添加一个POOL_BOUNDARY
,并返回它存放的内存地址;- 接着每有一个对象调用
autorelease
方法,会将它的内存地址添加进自动释放池中。pop
操做是传入一个POOL_BOUNDARY
的内存地址,从最后一个入栈的autorelease
对象开始,将自动释放池中的autorelease
对象所有释放(其实是给它们发送一条release
消息),直到遇到这个POOL_BOUNDARY
。
能够经过如下私有函数来查看自动释放池的状况:
extern void _objc_autoreleasePoolPrint(void);
复制代码
接下来咱们经过macOS
工程代码示例,结合AutoreleasePoolPage
的内存分布图以及_objc_autoreleasePoolPrint()
私有函数,来帮助咱们更好地理解@autoreleasepool
的原理。
注意: 因为
ARC
环境下不能调用autorelease
等方法,因此须要将工程切换为MRC
环境。
int main(int argc, const char * argv[]) {
_objc_autoreleasePoolPrint(); // print1
@autoreleasepool {
_objc_autoreleasePoolPrint(); // print2
HTPerson *p1 = [[[HTPerson alloc] init] autorelease];
HTPerson *p2 = [[[HTPerson alloc] init] autorelease];
_objc_autoreleasePoolPrint(); // print3
}
_objc_autoreleasePoolPrint(); // print4
return 0;
}
复制代码
// 自动释放池的状况
objc[68122]: ############## (print1)
objc[68122]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68122]: 0 releases pending. //当前自动释放池中没有任何对象
objc[68122]: [0x102802000] ................ PAGE (hot) (cold)
objc[68122]: ##############
objc[68122]: ############## (print2)
objc[68122]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68122]: 1 releases pending. //当前自动释放池中有1个对象,这个对象为POOL_BOUNDARY
objc[68122]: [0x102802000] ................ PAGE (hot) (cold)
objc[68122]: [0x102802038] ################ POOL 0x102802038 //POOL_BOUNDARY
objc[68122]: ##############
objc[68122]: ############## (print3)
objc[68122]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68122]: 3 releases pending. //当前自动释放池中有3个对象
objc[68122]: [0x102802000] ................ PAGE (hot) (cold)
objc[68122]: [0x102802038] ################ POOL 0x102802038 //POOL_BOUNDARY
objc[68122]: [0x102802040] 0x100704a10 HTPerson //p1
objc[68122]: [0x102802048] 0x10075cc30 HTPerson //p2
objc[68122]: ##############
objc[68156]: ############## (print4)
objc[68156]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68156]: 0 releases pending. //当前自动释放池中没有任何对象,由于@autoreleasepool做用域结束,调用pop方法释放了对象
objc[68156]: [0x100810000] ................ PAGE (hot) (cold)
objc[68156]: ##############
复制代码
int main(int argc, const char * argv[]) {
_objc_autoreleasePoolPrint(); // print1
@autoreleasepool { //r1 = push()
_objc_autoreleasePoolPrint(); // print2
HTPerson *p1 = [[[HTPerson alloc] init] autorelease];
HTPerson *p2 = [[[HTPerson alloc] init] autorelease];
_objc_autoreleasePoolPrint(); // print3
@autoreleasepool { //r2 = push()
HTPerson *p3 = [[[HTPerson alloc] init] autorelease];
_objc_autoreleasePoolPrint(); // print4
@autoreleasepool { //r3 = push()
HTPerson *p4 = [[[HTPerson alloc] init] autorelease];
_objc_autoreleasePoolPrint(); // print5
} //pop(r3)
_objc_autoreleasePoolPrint(); // print6
} //pop(r2)
_objc_autoreleasePoolPrint(); // print7
} //pop(r1)
_objc_autoreleasePoolPrint(); // print8
return 0;
}
复制代码
// 自动释放池的状况
objc[68285]: ############## (print1)
objc[68285]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68285]: 0 releases pending. //当前自动释放池中没有任何对象
objc[68285]: [0x102802000] ................ PAGE (hot) (cold)
objc[68285]: ##############
objc[68285]: ############## (print2)
objc[68285]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68285]: 1 releases pending. //当前自动释放池中有1个对象
objc[68285]: [0x102802000] ................ PAGE (hot) (cold)
objc[68285]: [0x102802038] ################ POOL 0x102802038 //POOL_BOUNDARY
objc[68285]: ##############
objc[68285]: ############## (print3)
objc[68285]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68285]: 3 releases pending. //当前自动释放池中有3个对象(1个@autoreleasepool)
objc[68285]: [0x102802000] ................ PAGE (hot) (cold)
objc[68285]: [0x102802038] ################ POOL 0x102802038 //POOL_BOUNDARY
objc[68285]: [0x102802040] 0x100707d80 HTPerson //p1
objc[68285]: [0x102802048] 0x100707de0 HTPerson //p2
objc[68285]: ##############
objc[68285]: ############## (print4)
objc[68285]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68285]: 5 releases pending. //当前自动释放池中有5个对象(2个@autoreleasepool)
objc[68285]: [0x102802000] ................ PAGE (hot) (cold)
objc[68285]: [0x102802038] ################ POOL 0x102802038 //POOL_BOUNDARY
objc[68285]: [0x102802040] 0x100707d80 HTPerson //p1
objc[68285]: [0x102802048] 0x100707de0 HTPerson //p2
objc[68285]: [0x102802050] ################ POOL 0x102802050 //POOL_BOUNDARY
objc[68285]: [0x102802058] 0x1005065b0 HTPerson //p3
objc[68285]: ##############
objc[68285]: ############## (print5)
objc[68285]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68285]: 7 releases pending. //当前自动释放池中有7个对象(3个@autoreleasepool)
objc[68285]: [0x102802000] ................ PAGE (hot) (cold)
objc[68285]: [0x102802038] ################ POOL 0x102802038 //POOL_BOUNDARY
objc[68285]: [0x102802040] 0x100707d80 HTPerson //p1
objc[68285]: [0x102802048] 0x100707de0 HTPerson //p2
objc[68285]: [0x102802050] ################ POOL 0x102802050 //POOL_BOUNDARY
objc[68285]: [0x102802058] 0x1005065b0 HTPerson //p3
objc[68285]: [0x102802060] ################ POOL 0x102802060 //POOL_BOUNDARY
objc[68285]: [0x102802068] 0x100551880 HTPerson //p4
objc[68285]: ##############
objc[68285]: ############## (print6)
objc[68285]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68285]: 5 releases pending. //当前自动释放池中有5个对象(第3个@autoreleasepool已释放)
objc[68285]: [0x102802000] ................ PAGE (hot) (cold)
objc[68285]: [0x102802038] ################ POOL 0x102802038
objc[68285]: [0x102802040] 0x100707d80 HTPerson
objc[68285]: [0x102802048] 0x100707de0 HTPerson
objc[68285]: [0x102802050] ################ POOL 0x102802050
objc[68285]: [0x102802058] 0x1005065b0 HTPerson
objc[68285]: ##############
objc[68285]: ############## (print7)
objc[68285]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68285]: 3 releases pending. //当前自动释放池中有3个对象(第二、3个@autoreleasepool已释放)
objc[68285]: [0x102802000] ................ PAGE (hot) (cold)
objc[68285]: [0x102802038] ################ POOL 0x102802038
objc[68285]: [0x102802040] 0x100707d80 HTPerson
objc[68285]: [0x102802048] 0x100707de0 HTPerson
objc[68285]: ##############
objc[68285]: ############## (print8)
objc[68285]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[68285]: 0 releases pending. //当前自动释放池没有任何对象(3个@autoreleasepool都已释放)
objc[68285]: [0x102802000] ................ PAGE (hot) (cold)
objc[68285]: ##############
复制代码
由AutoreleasePoolPage
类的定义可知,自动释放池(即全部的AutoreleasePoolPage
对象)是以栈
为结点经过双向链表
的形式组合而成。每当Page
满了的时候,就会建立一个新的Page
,并设置它为hotPage
,而首个Page
为coldPage
。接下来咱们来看一下多个Page
和多个@autoreleasepool
嵌套的状况。
int main(int argc, const char * argv[]) {
@autoreleasepool { //r1 = push()
for (int i = 0; i < 600; i++) {
HTPerson *p = [[[HTPerson alloc] init] autorelease];
}
@autoreleasepool { //r2 = push()
for (int i = 0; i < 500; i++) {
HTPerson *p = [[[HTPerson alloc] init] autorelease];
}
@autoreleasepool { //r3 = push()
for (int i = 0; i < 200; i++) {
HTPerson *p = [[[HTPerson alloc] init] autorelease];
}
_objc_autoreleasePoolPrint();
} //pop(r3)
} //pop(r2)
} //pop(r1)
return 0;
}
复制代码
一个AutoreleasePoolPage
对象的内存大小为4096
个字节,它自身成员变量占用内存56
个字节,因此剩下的4040
个字节用来存储autorelease
对象的内存地址。又由于64bit
下一个OC
对象的指针所占内存为8
个字节,因此一个Page
能够存放505
个对象的地址。POOL_BOUNDARY
也是一个对象,由于它的值为nil
。因此以上代码的自动释放池内存分布图以下所示。
objc[69731]: ##############
objc[69731]: AUTORELEASE POOLS for thread 0x1000aa5c0
objc[69731]: 1303 releases pending. //当前自动释放池中有1303个对象(3个POOL_BOUNDARY和1300个HTPerson实例)
objc[69731]: [0x100806000] ................ PAGE (full) (cold) /* 第一个PAGE,full表明已满,cold表明coldPage */
objc[69731]: [0x100806038] ################ POOL 0x100806038 //POOL_BOUNDARY
objc[69731]: [0x100806040] 0x10182a040 HTPerson //p1
objc[69731]: [0x100806048] ..................... //...
objc[69731]: [0x100806ff8] 0x101824e40 HTPerson //p504
objc[69731]: [0x102806000] ................ PAGE (full) /* 第二个PAGE */
objc[69731]: [0x102806038] 0x101824e50 HTPerson //p505
objc[69731]: [0x102806040] ..................... //...
objc[69731]: [0x102806330] 0x101825440 HTPerson //p600
objc[69731]: [0x102806338] ################ POOL 0x102806338 //POOL_BOUNDARY
objc[69731]: [0x102806340] 0x101825450 HTPerson //p601
objc[69731]: [0x102806348] ..................... //...
objc[69731]: [0x1028067e0] 0x101825d90 HTPerson //p1008
objc[69731]: [0x102804000] ................ PAGE (hot) /* 第三个PAGE,hot表明hotPage */
objc[69731]: [0x102804038] 0x101826dd0 HTPerson //p1009
objc[69731]: [0x102804040] ..................... //...
objc[69731]: [0x102804310] 0x101827380 HTPerson //p1100
objc[69731]: [0x102804318] ################ POOL 0x102804318 //POOL_BOUNDARY
objc[69731]: [0x102804320] 0x101827390 HTPerson //p1101
objc[69731]: [0x102804328] ..................... //...
objc[69731]: [0x102804958] 0x10182b160 HTPerson //p1300
objc[69731]: ##############
复制代码
从以上macOS
工程示例能够得知,在@autoreleasepool
大括号结束的时候,就会调用Page
的pop()
方法,给@autoreleasepool
中的autorelease
对象发送release
消息。
那么在iOS
工程中,方法里的autorelease
对象是何时释放的呢?有系统干预释放和手动干预释放两种状况。系统干预释放是不指定@autoreleasepool
,全部autorelease
对象都由main
函数中的@autoreleasepool
管理。手动干预释放就是将autorelease
对象添加进咱们手动建立的@autoreleasepool
。
下面仍是在MRC
环境下进行分析。
在iOS
工程的main()
函数中也有一个@autoreleasepool
,这个@autoreleasepool
负责了应用程序全部autorelease
对象的释放。
int main(int argc, char * argv[]) {
@autoreleasepool {
return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
}
}
复制代码
- (void)viewDidLoad {
[super viewDidLoad];
HTPerson *person = [[[HTPerson alloc] init] autorelease];
NSLog(@"%s", __func__);
}
- (void)viewWillAppear:(BOOL)animated
{
[super viewWillAppear:animated];
NSLog(@"%s", __func__);
}
- (void)viewDidAppear:(BOOL)animated
{
[super viewDidAppear:animated];
NSLog(@"%s", __func__);
}
// -[ViewController viewDidLoad]
// -[ViewController viewWillAppear:]
// -[HTPerson dealloc]
// -[ViewController viewDidAppear:]
复制代码
能够看到,调用了autorelease
方法的person
对象不是在viewDidLoad
方法结束后释放,而是在viewWillAppear
方法结束后释放,说明在viewWillAppear
方法结束的时候,调用了pop()
方法释放了person
对象。其实这是由RunLoop
控制的,下面来说解一下RunLoop
和@autoreleasepool
的关系。
学习这个知识点以前,须要先搞懂
RunLoop
的事件循环机制以及它的6
种活动状态,能够查看个人文章:
《深刻浅出 RunLoop(二):数据结构》
《深刻浅出 RunLoop(三):事件循环机制》
iOS
在主线程的RunLoop
中注册了两个Observer
。
Observer
监听了kCFRunLoopEntry
事件,会调用objc_autoreleasePoolPush()
;Observer
kCFRunLoopBeforeWaiting
事件,会调用objc_autoreleasePoolPop()
、objc_autoreleasePoolPush()
;kCFRunLoopBeforeExit
事件,会调用objc_autoreleasePoolPop()
。因此,在iOS
工程中系统干预释放的autorelease
对象的释放时机是由RunLoop
控制的,会在当前RunLoop
每次循环结束时释放。以上person
对象在viewWillAppear
方法结束后释放,说明viewDidLoad
和viewWillAppear
方法在同一次循环里。
kCFRunLoopEntry
:在即将进入RunLoop
时,会自动建立了一个__AtAutoreleasePool
结构体对象,并调用objc_autoreleasePoolPush()
函数。kCFRunLoopBeforeWaiting
:在RunLoop
即将休眠时,会自动销毁一个__AtAutoreleasePool
对象,调用objc_autoreleasePoolPop()
。而后建立一个新的__AtAutoreleasePool
对象,并调用objc_autoreleasePoolPush()
。kCFRunLoopBeforeExit
,在即将退出RunLoop
时,会自动销毁最后一个建立的__AtAutoreleasePool
对象,并调用objc_autoreleasePoolPop()
。咱们再来看一下手动干预释放的状况。
- (void)viewDidLoad {
[super viewDidLoad];
@autoreleasepool {
HTPerson *person = [[[HTPerson alloc] init] autorelease];
}
NSLog(@"%s", __func__);
}
- (void)viewWillAppear:(BOOL)animated
{
[super viewWillAppear:animated];
NSLog(@"%s", __func__);
}
- (void)viewDidAppear:(BOOL)animated
{
[super viewDidAppear:animated];
NSLog(@"%s", __func__);
}
// -[HTPerson dealloc]
// -[ViewController viewDidLoad]
// -[ViewController viewWillAppear:]
// -[ViewController viewDidAppear:]
复制代码
能够看到,添加进手动指定的@autoreleasepool
中的autorelease
对象,在@autoreleasepool
大括号结束时就会释放,不受RunLoop
控制。
以上都是在MRC
环境下分析,由于ARC
下不能给对象调用retain
release
、autorelease
等方法。
那ARC
中方法里的局部对象何时释放?其实只要知道LLVM
编译器在编译时给对象插入release
仍是autorelease
方法就知道了。
alloc
/new
/copy
/mutableCopy
方法建立的对象,LLVM
编译器在编译时会给对象插入release
方法,因此这类局部对象,在方法结束时就会释放。LLVM
编译器在编译时会给对象插入autorelease
方法,因此这类对象的释放时机由RunLoop
控制。回到咱们最初的面试题,在ARC
环境下,autorelease
对象在何时释放?咱们就分系统干预释放
和手动干预释放
两种状况回答。
iOS
工程在ARC
环境下,main
函数中的@autoreleasepool
负责了应用程序全部autorelease
对象的释放。一般状况下咱们不须要手动添加@autoreleasepool
,可是若是咱们须要在循环中建立了不少临时的autorelease
对象,则手动添加@autoreleasepool
来管理这些对象能够很大程度地减小内存峰值。好比在for
循环中alloc
图片数据等内存消耗较大的场景,须要手动添加@autoreleasepool
。
苹果给出了三种须要手动添加
@autoreleasepool
的状况:
- ① 若是你编写的程序不是基于 UI 框架的,好比说命令行工具;
- ② 若是你编写的循环中建立了大量的临时对象;
你能够在循环内使用@autoreleasepool
在下一次迭代以前处理这些对象。在循环中使用@autoreleasepool
有助于减小应用程序的最大内存占用。- ③ 若是你建立了辅助线程。
一旦线程开始执行,就必须建立本身的@autoreleasepool
;不然,你的应用程序将存在内存泄漏。(有关详细信息,请参见自动释放池块和线程。)
更多关于@autoreleasepool
的使用能够查看苹果官方文档《Advanced Memory Management Programming Guide》。