iOS autoreleasePool原理总结

lanlinxl
2,602 阅读8分钟

目录

1. autorelease的本质

2. autoreleasepool的源码解析

3. autoreleasePoolPage的结构

4. autoreleasePool的结构和工作原理

5.autoreleasepool的嵌套

6. autorelaeasepool、NSRunLoop 、子线程三者的关系

1.autorelease的本质

  • autorelease本质就是延迟调用release方法 MRC环境下，通过[obj autorelease]来延迟内存的释放 ARC环境下，是不能手动调用，系统会自动给对象添加autorelease

2.autoreleasepool的源码解析

进入工程main.m文件中

int main(int argc, char * argv[]) {
    @autoreleasepool {
        ///ARC下会自动加入 autorelease方法
        NSObject * obj = [[NSObject alloc] init];
        ///MRC写法
        // NSObject * obj = [[[NSObject alloc] init] autorelease];
    }
}

进入终端,cd到main.m文件目录下，运行以下命令，将文件转换为main.cpp文件查看底层调用方法： xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp 在生成的main.cpp文件中我们可发现main函数被转化成下面C代码：

int main(int argc, char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; ///调用了objc_autoreleasePoolPush
        NSObject * obj = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));
    }
}

查看__AtAutoreleasePool发现是一个C的结构体

struct __AtAutoreleasePool {
  __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
  ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
  void * atautoreleasepoolobj;
};

这里面主要包含了两个方法:

1. __AtAutoreleasePool() { atautoreleasepoolobj = objc_autoreleasePoolPush(); }:构造函数，在创建结构体时调用

2. ~__AtAutoreleasePool() { objc_autoreleasePoolPop(atautoreleasepoolobj); }:析构函数，在销毁结构体时调用
  • 为了方便，将代码转换为以下伪代码：
int main (int argc, char * argv[]) {
// push 
void *poolToken = objc_autoreleasePoolPush();
  这中间为写在{...}中的代码
// pop 将{...}中的对象都执行一次 release操作  
objc_autoreleasePoolPop(哨兵对象地址);//哨兵对象后面会讲到
}

-上面提到objc_autoreleasePoolPush()和 objc_autoreleasePoolPop(atautoreleasepoolobj)两个方法，看看源码实现(只保留重要部分)：

void * objc_autoreleasePoolPush(void)
{
    return AutoreleasePoolPage::push();
}

void objc_autoreleasePoolPop(void *ctxt)
{
    AutoreleasePoolPage::pop(ctxt);
}
  • 3.push相关函数的关键代码分析：
//哨兵对象 一个宏定义的nil对象
# define POOL_BOUNDARY  nil

void * objc_autoreleasePoolPush(void)
{
    return AutoreleasePoolPage::push();
}

static inline void *push()
{
    return autoreleaseFast(POOL_BOUNDARY);
}

static inline id *autoreleaseFast(id obj)
{
   //hotPage()表示当前页的 AutoreleasePoolPage 节点
    AutoreleasePoolPage *page = hotPage(); 
    if (page && !page->full()) {
     // 当前 page 存在且没有满时，直接将对象添加到当前 page 中，即 next 指向的位置
        return page->add(obj); 
    } else if (page) { 
       // 当前 page 存在且已满时，创建一个新的 page ，并将对象添加到新创建的 page 中
        return autoreleaseFullPage(obj, page); 
    } else {
        // 当前 page 不存在时，即还没有 page 时，创建第一个 page ，并将对象添加到新创建的 page 中
        return autoreleaseNoPage(obj); 
    }
}
[obj autorelease], 给对象添加 autorelease 方法, 其实内部就是直接调用了 autoreleaseFast
  • 4.pop相关函数的关键代码分析：
static inline void pop(void *token)  {
        AutoreleasePoolPage *page;
        id *stop;
        page = pageForPointer(token);
        stop = (id *)token;
        //判断是否为哨兵对象POOL_BOUNDARY
        if (*stop != POOL_BOUNDARY) {
            if (stop == page->begin()  &&  !page->parent) {
                //特殊情况stop不为哨兵对象POOL_BOUNDARY，也可以,苹果给了下面两个原因：
                // 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 {
                //错误情况，return异常处理
                // Error. For bincompat purposes this is not 
                // fatal in executables built with old SDKs.
                return badPop(token);
            }
        }

        //上面条件判断得知stop为page->begin()，page->begin()大部分情况是哨兵对象POOL_BOUNDARY
        //这行代码是重点
        page->releaseUntil(stop);
        
        // 经过上面release操作后，移除已经释放完的page，并做相关处理
        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方法里面调用releaseUntil进行对象释放
  void releaseUntil(id *stop) {
        //从后往前移除，直到为stop（一般为哨兵对象POOL_BOUNDARY）停止循环
        while (this->next != stop) {
            AutoreleasePoolPage *page = hotPage();
            //如果当前页面为空，则找上一页page
            while (page->empty()) {
                page = page->parent;
                setHotPage(page);
            }
            page->unprotect();
            id obj = *--page->next;
            memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
            page->protect();
            //当前对象不是哨兵对象，就调用release操作释放
            if (obj != POOL_BOUNDARY) {
                objc_release(obj);
            }
        }
        setHotPage(this);
    }
  • 以上就是push和pop的关键源码分析。

由此发现autoreleasePool是依赖AutoreleasePoolPage实现的，具体里面实现后面再说，先来看看AutoreleasePoolPage的结构。

3.autoreleasePoolPage的结构

以下为AutoreleasePoolPage结构的主要部分

class AutoreleasePoolPage 
{
    PAGE_MAX_SIZE；//最大size 4096字节
    magic_t const magic; //用来校验AutoreleasePoolPage的结构是否完整
    id *next;//指向下一个即将产生的autoreleased对象的存放位置（当next == begin()时，表示AutoreleasePoolPage为空；当next == end()时，表示AutoreleasePoolPage已满
    pthread_t const thread;//指向当前线程，一个AutoreleasePoolPage只会对应一个线程，但一个线程可以对应多个AutoreleasePoolPage；
    AutoreleasePoolPage * const parent;//指向父结点，第一个结点的 parent 值为 nil；
    AutoreleasePoolPage *child;//指向子结点，最后一个结点的 child 值为 nil；
    uint32_t const depth;//代表深度，第一个page的depth为0，往后每递增一个page，depth会加1；
}

如下图： AutoreleasePoolPage结构图.png

  • 1.AutoreleasePoolPage 本质是这么一个节点对象，大小是4096字（PAGE_MAX_SIZE：4096）。
  • 2.前7个变量都是8字节，所以总共占用56个字节，剩下的4040字节存储着autorelease对象地址

4.autoreleasePool的结构和工作原理

  • autoreleasepool本质上就是一个指针堆栈,内部结构是由若干个以AutoreleasePoolPage对象为结点的双向链表组成，系统会在需要的时候动态地增加或删除page节点，如下图即为AutoreleasePoolPage组成的双向链表： 截屏2021-03-05 下午4.39.46.png
  • 参考上图，整个流程大概如下：

1.在运行循环开始前，系统会自动创建一个autoreleasepool(一个autoreleasepool会存在多个AutoreleasePoolPage)，此时会调用一次objc_autoreleasePoolPush函数，runtime会向当前的AutoreleasePoolPage中add进一个POOL_BOUNDARY（哨兵对象），代表autoreleasepool的起始边界地址），并返回此哨兵对象的内存地址。

2.这时候next指针则会指向POOL_BOUNDARY（哨兵对象）后面的地址（对象地址1）。

3.后面我们创建对象，如果对象调用了autorelease方法（ARC编译器会给对象自动插入autorelease），则会被添加进AutoreleasePoolPage中，位置是在next指针指向的位置，如上面next指向的是对象地址1，这是后添加的对象地址就在对象地址1这里，然后next就会 指向到对象地址2 ，以此类推，每添加一个地址就会向前移动一次，直到指向end()表示已存满。

4.当不断的创建对象时，AutoreleasePoolPage不断存储对象地址，直到存满后，则又会创建一个新的AutoreleasePoolPage，使用child指针和parent指针指向下一个和上一个page，从而形成一个双向链表，对象地址存储的顺序如图所示。

5.当调用objc_autoreleasePoolPop(哨兵对象地址)时（调用时机后面说），假设我们如上图，添加最后一个对象地址8，那么这时候就会依次由对象地址8 -> 对象地址1，每个对象都会调用release方法释放，直到遇到哨兵对象地址为止。

  • _objc_autoreleasePoolPush()和 _objc_autoreleasePoolPop的调用时机

App启动后主线程的RunLoop注册两个observer：_warpRunLoopWithAutoreleasePoolHandle()
第一个observer监听事件Entry，回调调用_objc_autoreleasePoolPush()创建自动释放池，优先级最高，保证创建释放池发生在其他所有回调之前。
第二个observer监听两个事件：
1.Before waiting时调用_objc_autoreleasePoolPop和push清空自动释放池。
2.Exit时调用_objc_autoreleasePoolPop释放清空。
优先级最低，保证其释放池子发生在其他所有回调之后。

5.autoreleasepool的嵌套

当多个autoreleasepool嵌套，对象的释放，会是什么情况呢？ 每次新建一个@ autoreleasepool,就会执行一次push操作，对应的具体实现就是往AutoreleasePoolPage中的next位置插入一个POOL_BOUNDARY（哨兵对象）。 如下：

@autoreleasepool   {//autoreleasepool1
       NSObject * obj1 = [[NSObject alloc] init];
   
    @autoreleasepool  {//autoreleasepool2
        NSObject * obj2 = [[NSObject alloc] init];
        NSObject * obj3 = [[NSObject alloc] init];
    }
}

autoreleasepool的嵌套.png

释放流程：

  1. 当autoreleasepool1创建时，会添加哨兵对象1，接着obj1的创建，则把obj1地址添加进来。

  2. 当autoreleasepool2创建，会添加哨兵对象2，位置是obj1后面（上面next指针指向原理），然后依次把obj2和obj3加进来。

  3. 当autoreleasepool2结束时，obj3，obj2，会找到离它们最近的autoreleasepool即 autoreleasepool2，然后依次调用release，直到哨兵对象2位置。

  4. 当autoreleasepool1结束时，当obj1调用release，直到哨兵对象1位置，

6. autorelaeasepool、NSRunLoop 、子线程三者的关系

  1. 主线程默认为我们开启 Runloop，Runloop 会自动帮我们创建Autoreleasepool，并进行Push、Pop 等操作来进行内存管理。

  2. 子线程默认不开启runloop,当产生autorelease对象时候，会将对象添加到最近一次创建的autoreleasepool中，一般是main函数中的autoreleasepool，由主线程runloop管理；也就是不用手动创建Autoreleasepool，线程销毁时在会在最近一次创建的autoreleasepool 中释放对象。

  3. 自定义的 NSOperation 和 NSThread 需要手动创建自动释放池。比如： 自定义的 NSOperation 类中的 main 方法里就必须添加自动释放池。否则出了作用域后，自动释放对象会因为没有自动释放池去处理它，而造成内存泄露。但对于 blockOperation 和 invocationOperation 这种默认的Operation ，系统已经帮我们封装好了，不需要手动创建自动释放池。

  4. AutoreleasePool是按线程一一对应的(结构中的thread指针指向当前线程）,每开一个线程，会有与之对应的AutoreleasePool。

点个赞再走呗～

avatar
文章
阅读
粉丝