内存管理二

Autoreleasepool

Autoreleasepool的结构

我们的main函数中定义一个自动释放池

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
    }
    
    return 0;
}

然后通过clang查看源码实现

/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

    }

可以看到我们的@autoreleasepool转换成了__AtAutoreleasePool，__AtAutoreleasePool的实现如下：

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

__AtAutoreleasePool有两个方法，一个是push()，一个是pop()。
通过符号断点的方式可以确定objc_autoreleasePoolPush在objc的源码中，然后我们找到对应的源码：

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

调用了AutoreleasePoolPage的push()函数。AutoreleasePoolPage是一页，相当于自动释放池中的好多对象组成了这样的一页，然后每一页又连起来形成了一个双向的链表结构。定位到AutoreleasePoolPage的定义：

/***********************************************************************
   Autorelease pool implementation
    // 先进后出
   A thread's autorelease pool is a stack of pointers. 
   Each pointer is either an object to release, or POOL_BOUNDARY which is 
     an autorelease pool boundary.
   A pool token is a pointer to the POOL_BOUNDARY for that pool. When 
     the pool is popped, every object hotter than the sentinel is released.
   The stack is divided into a doubly-linked list of pages. Pages are added 
     and deleted as necessary. 
   Thread-local storage points to the hot page, where newly autoreleased 
     objects are stored. 
**********************************************************************/
class AutoreleasePoolPage : private AutoreleasePoolPageData

通过注释我们可以发现：

• AutoreleasePoolPage是个栈的结构，也就是先进后出；
• AutoreleasePoolPage中的节点有两种：要释放的对象以及pool boundary(也就是边界值)。
• page会组成一个双向链接的结构；
• tls 线程存储；

然后看下AutoreleasePoolPageData的实现：

struct AutoreleasePoolPageData
{
    magic_t const magic; // 16
    __unsafe_unretained id *next; //8
    pthread_t const thread; // 8
    AutoreleasePoolPage * const parent; //8
    AutoreleasePoolPage *child; //8
    uint32_t const depth; // 4
    uint32_t hiwat; // 4

    AutoreleasePoolPageData(__unsafe_unretained id* _next, pthread_t _thread, AutoreleasePoolPage* _parent, uint32_t _depth, uint32_t _hiwat)
        : magic(), next(_next), thread(_thread),
          parent(_parent), child(nil),
          depth(_depth), hiwat(_hiwat)
    {
    }
};

next是定位偏移；thread为关联的线程；parent为父节点；child为子节点；
下面我们看下AutoreleasePoolPage的初始化方法：

AutoreleasePoolPage(AutoreleasePoolPage *newParent) :
        AutoreleasePoolPageData(begin(),
                                objc_thread_self(),
                                newParent,
                                newParent ? 1+newParent->depth : 0,
                                newParent ? newParent->hiwat : 0)
    { 
        if (parent) {
            parent->check();
            ASSERT(!parent->child);
            parent->unprotect();
            parent->child = this;
            parent->protect();
        }
        protect();
    }

可见，初始化方法中调用了AutoreleasePoolPageData的初始化方法，传入了begin()。begin()就是AutoreleasePoolPage的地址除去上面的那个magic、next、thread、parrent、child等属性后的位置。也就是开始存储pointer的地方了。
自动释放池的结构如下，每个AutoreleasePoolPage作为一个双向链表的节点。AutoreleasePoolPage的头部位置存储着一些属性：magic、next等。

自动释放池的结构

下面我们向自动释放池中添加一些对象，然后打印一下

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        for (int i = 0; i<5; i++) {
            NSObject *obj = [[NSObject alloc] autorelease];
            NSLog(@"%@", obj);
        }
        _objc_autoreleasePoolPrint();
    }
    
    return 0;
}

打印结果如下：

objc[18996]: ##############
objc[18996]: AUTORELEASE POOLS for thread 0x1000d1dc0
objc[18996]: 6 releases pending.
objc[18996]: [0x100804000]  ................  PAGE  (hot) (cold)
objc[18996]: [0x100804038]  ################  POOL 0x100804038
objc[18996]: [0x100804040]       0x1006b8ee0  NSObject
objc[18996]: [0x100804048]       0x101100200  NSObject
objc[18996]: [0x100804050]       0x101300020  NSObject
objc[18996]: [0x100804058]       0x10063d6c0  NSObject
objc[18996]: [0x100804060]       0x1006b5e60  NSObject
objc[18996]: ##############

地址0x100804000到0x100804038存储的是AutoreleasePoolPage的一些头部属性信息。然后从0x100804038开始存储了6个对象，但是我们自己是创建了5个对象。还有一个就是我们哨兵对象，也就是边界对对象。这个边界对象是自动释放池的边界，当嵌套使用自动释放池的时候，每个自动释放池都会有对象的边界。
当我们自动释放池的对象超过505的时候，就会进行分页，创建新的AutoreleasePoolPage。也就是说一个AutoreleasePoolPage只能装505个对象，注意因为第一个需要有个边界对象，所以只能有504个对象。

Autoreleasepool的压栈

首先找到objc_autoreleasePoolPush函数，调用了push函数

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

push函数中调用autoreleaseFast函数

static inline void *push() 
    {
        id *dest;
        if (slowpath(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;
    }

autoreleaseFast函数中，如果存在page并且page没有满，就会调用page->add(obj)函数向page中添加对象；如果page已满了，调用autoreleaseFullPage；如果还没有创建page，那么使用autoreleaseNoPage进行创建。

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);
    }
}

• 首先我们来看下创建page的函数autoreleaseNoPage

// 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);

主要就是创建了Page，然后设置为聚焦page，如果是第一个page就先插入边界，然后再插入对象。

• 然后看下page->add(obj)函数向存在的page中添加对象。

id *add(id obj)
{
    ASSERT(!full());
    unprotect();
    id *ret = next;  // faster than `return next-1` because of aliasing
    *next++ = obj;
    protect();
    return ret;
}

很简单，就是移动next的位置，指向obj。

• 最后我们看下page满的情况：autoreleaseFullPage函数实现

do {
    if (page->child) page = page->child;
    else page = new AutoreleasePoolPage(page);
} while (page->full());

setHotPage(page);
return page->add(obj);

一个doWhile循环，查找child，也就是双链表中的那个节点。知道找到没有装满的page，如果找到最后找不到，就创建一个新的。然后设置为hotPage，最后添加对象进去。
上面就是我们的压栈过程。

Autoreleasepool的出栈

首先是objc_autoreleasePoolPop函数，该函数的参数是调用pagePush的时候返回的对象。也就是该page的上下文标识。

void
objc_autoreleasePoolPop(void *ctxt)
{
    AutoreleasePoolPage::pop(ctxt);
}

然后调用pop函数，pop函数的主要内容为：

AutoreleasePoolPage *page;
id *stop;
page = pageForPointer(token);
stop = (id *)token;
return popPage(token, page, stop);

根据上下文找到对应的page，然后调用popPage函数。popPage函数的试下如下：

popPage(void *token, AutoreleasePoolPage *page, id *stop)
{
    if (allowDebug && PrintPoolHiwat) printHiwat();

    page->releaseUntil(stop);

    // memory: delete empty children
    if (allowDebug && DebugPoolAllocation  &&  page->empty()) {
        // special case: delete everything during page-per-pool debugging
        AutoreleasePoolPage *parent = page->parent;
        page->kill();
        setHotPage(parent);
    } else if (allowDebug && 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();
        }
    }
}

调用page->releaseUntil(stop);释放对象。后面就是对page的kill处理以及setHotPage处理。下面看下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;
        memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
        page->protect();

        if (obj != POOL_BOUNDARY) {
            objc_release(obj);
        }
    }

    setHotPage(this);
}

一个while循，移动next指，依次给对象发送release消息，如果page为空，就开始处理父节点，设置父节点为hotPage，直到遍历到边界。

Autoreleasepool的嵌套

下面的代码中，我们开启了一个子线程，子线程会自动创建一个自动释放池。

@autoreleasepool {
    // insert code here...
    // 1 + 504 + 505 + 505
    NSObject *objc = [[NSObject alloc] autorelease];
    NSLog(@"objc = %@",objc);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSObject *obj = [[NSObject alloc] autorelease];
            NSLog(@"\n\n obj = %@",obj);
            _objc_autoreleasePoolPrint();
    });
    _objc_autoreleasePoolPrint();
}

然后我们得到下面的打印结果：

2020-03-22 22:03:55.610864+0800 KCObjcTest[20399:607121] objc = 
objc[20399]: ##############
objc[20399]: AUTORELEASE POOLS for thread 0x1000d2dc0
objc[20399]: 2 releases pending.
objc[20399]: [0x100812000]  ................  PAGE  (hot) (cold)
objc[20399]: [0x100812038]  ################  POOL 0x100812038
objc[20399]: [0x100812040]       0x100686c80  NSObject
objc[20399]: ##############
2020-03-22 22:03:55.612082+0800 KCObjcTest[20399:607493] 

 obj = 
objc[20399]: ##############
objc[20399]: AUTORELEASE POOLS for thread 0x70000e5c0000
objc[20399]: 2 releases pending.
objc[20399]: [0x102802000]  ................  PAGE  (hot) (cold)
objc[20399]: [0x102802038]  ################  POOL 0x102802038
objc[20399]: [0x102802040]       0x1010026e0  NSObject
objc[20399]: ##############

因为自动释放池是和线程相关的，所以主线程和子线程都会创建对应线程的AutoReleasePool，然后分别存储一个边界对象和一个正常的对象。
下面我们在子线程中再次手动创建一个autoreleasepool，那么子线程就会有两个autoreleasepool了。

@autoreleasepool {
    // insert code here...
    // 1 + 504 + 505 + 505
    NSObject *objc = [[NSObject alloc] autorelease];
    NSLog(@"objc = %@",objc);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        @autoreleasepool {
            NSObject *obj = [[NSObject alloc] autorelease];
            NSLog(@"\n\n obj = %@",obj);
            _objc_autoreleasePoolPrint();
       }
    });
    _objc_autoreleasePoolPrint();
}

打印结果如下：

2020-03-22 22:07:02.159829+0800 KCObjcTest[20445:609384] objc = 
objc[20445]: ##############
objc[20445]: AUTORELEASE POOLS for thread 0x1000d2dc0
objc[20445]: 2 releases pending.
2020-03-22 22:07:02.161109+0800 KCObjcTest[20445:609762] 

 obj = 
objc[20445]: [0x102803000]  ................  PAGE  (hot) (cold)
objc[20445]: [0x102803038]  ################  POOL 0x102803038
objc[20445]: [0x102803040]       0x100712a10  NSObject
objc[20445]: ##############
objc[20445]: ##############
objc[20445]: AUTORELEASE POOLS for thread 0x700007752000
objc[20445]: 3 releases pending.
objc[20445]: [0x101801000]  ................  PAGE  (hot) (cold)
objc[20445]: [0x101801038]  ################  POOL 0x101801038
objc[20445]: [0x101801040]  ################  POOL 0x101801040
objc[20445]: [0x101801048]       0x100644f60  NSObject
objc[20445]: ##############
Program ended with exit code: 0

可见子线程中的page中变成了3个对象，有两个边界。分别标识这两个autoreleasepool的作用域。但是一个线程值创建了一个page。

RunLoop

RunLoop的底层实现是个doWhile循环。

void CFRunLoopRun(void) {    /* DOES CALLOUT */
    int32_t result;
    do {
        result = CFRunLoopRunSpecific(CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 1.0e10, false);
        CHECK_FOR_FORK();
    } while (kCFRunLoopRunStopped != result && kCFRunLoopRunFinished != result);
}

依赖于RunLoop的六大事件：

RunLoop六大事件

我们通过CFRunLoopGetMain来获取runLoop。

CFRunLoopRef CFRunLoopGetMain(void) {
    CHECK_FOR_FORK();
    static CFRunLoopRef __main = NULL; // no retain needed
    if (!__main) __main = _CFRunLoopGet0(pthread_main_thread_np()); // no CAS needed
    return __main;
}

_CFRunLoopGet0的主要实现：创建一个dict，然后将线程和runloop对应着放到dict中。所以说RunLoop和线程是一一对应的。

CFMutableDictionaryRef dict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, NULL, &kCFTypeDictionaryValueCallBacks);
// 进行绑定 dict[@"pthread_main_thread_np"] = mainLoop
CFDictionarySetValue(dict, pthreadPointer(pthread_main_thread_np()), mainLoop);

CFRunLoopRef newLoop = __CFRunLoopCreate(t);
CFDictionarySetValue(__CFRunLoops, pthreadPointer(t), newLoop);

RunLoop是个结构体，包含的以下内容：

pthread_t _pthread;
CFMutableSetRef _commonModes;
CFMutableSetRef _commonModeItems;
CFRunLoopModeRef _currentMode;
CFMutableSetRef _modes;

_pthread为绑定的线程，还有包含的modes、items。他们的关系图如下：

runLoop结构

一个runLoop对应一个线程，对应N个Mode。一个Mode对应N个source、timer、observer。

RunLoop调用timer等事件

下面我们看下timer事件是怎么依赖于RunLoop执行的呢？
首先我们创建一个timer，然后在timer的执行block的地方打上断点，查看堆栈调用情况。

timer的调用栈

在timer的block执行之前的函数调用顺序为：
__CFRunLoopRun，__CFRunLoopDoTimers(timer事件可能会有很多，所以是个集合体)， __CFRunLoopDoTimer， __CFRUNLOOP_IS_CALLING_OUT_TO_A_TIMER_CALLBACK_FUNCTION__
如果是其他的事件的话，流程相似，只不过是换成对应的__CFRunLoopDoSources0、__CFRunLoopDoSource1、__CFRunLoopDoObservers、__CFRunLoopDoBlocks。

RunLoop的函数实现

• 通知观察者即将进入RunLoop；
• 使用dispatch_source_t构建一个定时器来控制runLoop的超时退出。CFRunLoopRun() 默认的超时时间很大，所以直接设置为不超时，此时就不需要定时器了;
• 然后进入一个doWhile循环;
• 这里有个内循环，用于接收等待端口的消息。进入此循环后，线程进入休眠，直到收到新消息才跳出该循环，继续执行run loop；
  调用 mach_msg 等待接受 mach_port 的消息。线程将进入休眠, 直到被下面某一个事件唤醒。
  1、一个基于 port 的Source 的事件；
  2、一个 Timer 到时间了；
  3、RunLoop 自身的超时时间到了；
  4、被其他什么调用者手动唤醒。

RunLoop循环退出的条件：
1、进入loop时标记了stopAfterHandle参数，也就是处理完事件就返回，那么处理完成事件后直接退出；
2、timer到期了；
3、被外部调用者强制停止了，通过CFRunLoopStop函数设置的；
4、设置停止，通过_CFRunLoopStopMode设置停止；
5、source/timer/observer一个都没有了。

RunLoop的流程图