OC内存管理(二) 弱引用表和AutoreleasePool

Weak弱引用表

Weak原理

objc_initWeak

• 查看汇编可以得知，添加__weak修饰会走到objc_initWeak函数，这个过程是由LLVM来决定的。

id
objc_initWeak(id *location, id newObj) // location weak指针地址，newObj object对象
{
    if (!newObj) {
        *location = nil;
        return nil;
    }
    return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
      (location, (objc_object*)newObj);
}

• storeWeak

enum CrashIfDeallocating {
  DontCrashIfDeallocating = false, DoCrashIfDeallocating = true
};
template <HaveOld haveOld, HaveNew haveNew,
        enum CrashIfDeallocating crashIfDeallocating>
static id 
storeWeak(id *location, objc_object *newObj)
{
    ASSERT(haveOld  ||  haveNew);
    if (!haveNew) ASSERT(newObj == nil);
    Class previouslyInitializedClass = nil;
    id oldObj;
    SideTable *oldTable;
    SideTable *newTable;
 retry:
    if (haveOld) { ... } else { ... }
    if (haveNew) {
        newTable = &SideTables()[newObj]; // 获取对象的散列表
    } else { ... }

    SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable); // 对散列表进行加锁

    if (haveOld  &&  *location != oldObj) { ... }
    // 通过确保没有弱引用对象具有未+初始化的isa，可以防止弱引用机制和+初始化机制之间的死锁
    if (haveNew  &&  newObj) { ... }
    // 销毁时调用方法
    if (haveOld) { 
       weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
    }

  // Assign new value, if any.
  if (haveNew) {
      newObj = (objc_object *)
          weak_register_no_lock(&newTable->weak_table, (id)newObj, location, 
                                crashIfDeallocating ? CrashIfDeallocating : ReturnNilIfDeallocating);
      // weak_register_no_lock returns nil if weak store should be rejected

      // Set is-weakly-referenced bit in refcount table.
      if (!newObj->isTaggedPointerOrNil()) { ... }

      // Do not set *location anywhere else. That would introduce a race.
      *location = (id)newObj;
  }
  else { }
  
  SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable); // 解锁
  callSetWeaklyReferenced((id)newObj);
  return (id)newObj;
}

weak_register_no_lock：

id 
weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                    id *referrer_id, WeakRegisterDeallocatingOptions deallocatingOptions)
{
    objc_object *referent = (objc_object *)referent_id; // referent：newObject, NSObject 对象
    objc_object **referrer = (objc_object **)referrer_id; // location指针，也就是weak指针
    if (referent->isTaggedPointerOrNil()) return referent_id;

    // ensure that the referenced object is viable
    if (deallocatingOptions == ReturnNilIfDeallocating ||
        deallocatingOptions == CrashIfDeallocating) {
        bool deallocating;
        if (!referent->ISA()->hasCustomRR()) {
            deallocating = referent->rootIsDeallocating(); // 返回false
        }
        else { ... }
        if (deallocating) { ... }
    }
    // now remember it and where it is being stored
    weak_entry_t *entry;
    //方法的核心就是根据`referent`对象去查找`weak_table`中的`weak_entries`链表中的`weak_entry_t`对象`entry`
    if ((entry = weak_entry_for_referent(weak_table, referent))) { // 根据对象获取承载对象的weak_entry_t
        append_referrer(entry, referrer); // 如果存在则将`weak指针`存入`weak_entry_t`中的`referrers`链表中，存储时 **需要遵循 3/4 两倍扩容规则**。
    } 
    else { // 不存在则根据`object对象`和`weak指针`创建一个新的`entry`，再将`entry`插入`weak_table`的`weak_entries`链表中。
        weak_entry_t new_entry(referent, referrer); // 创建weak_entry_t
        weak_grow_maybe(weak_table); // 查看weak_table的size判断是否需要扩容
        weak_entry_insert(weak_table, &new_entry); // 插入
    }
    // Do not set *referrer. objc_storeWeak() requires that the 
    // value not change.
    return referent_id;
}

根据分析得知__weak并没有引起引用计数的变化，那么也就是说weak对象引用计数变化的因素和打印时调用weak对象有关，通过断点汇编分析，打印时代码会走到objc_loadWeak方法

objc_loadWeak

id
objc_loadWeak(id *location)
{
    if (!*location) return nil;
    return objc_autorelease(objc_loadWeakRetained(location));
}

• objc_loadWeakRetained：

  id
  objc_loadWeakRetained(id *location)
  {
      id obj;
      id result;
      Class cls;
      SideTable *table;
   retry:
      // fixme std::atomic this load
      obj = *location; // 根据weak指针获取object对象
      if (obj->isTaggedPointerOrNil()) return obj;
    
      table = &SideTables()[obj]; // 根据object对象获取散列表
      table->lock(); // 加锁 
      if (*location != obj) { ... }
      
      result = obj; 
      cls = obj->ISA();
      if (! cls->hasCustomRR()) {
          ASSERT(cls->isInitialized());
          if (! obj->rootTryRetain()) { // obj引用计数变化
              result = nil;
          }
      }
      else { ... }
      table->unlock();
      return result;
  }
  

  • 根据断点走发现，最终代码进入了rootTryRetain

• rootTryRetain：

  ALWAYS_INLINE bool 
  objc_object::rootTryRetain()
  {
      return rootRetain(true, RRVariant::Fast) ? true : false;
  }
  

  最终走到了我们熟悉的代码rootRetain，原来在此处进行引用计数+1。

• 在使用weak对象时，会短暂的进行引用计数+1，但使用过后会调用objc_release方法进行进行引用计数-1，所以多次调用打印wushuang时，引用计数始终是2

objc_destroyWeak

• weak对象销毁时会调用objc_destroyWeak，最终代码也会进入storeWeak，通过上面的分析得知，销毁的核心代码是调用weak_unregister_no_lock，核心代码如下：

void
weak_unregister_no_lock(weak_table_t *weak_table, id referent_id, 
                      id *referrer_id)
{
    objc_object *referent = (objc_object *)referent_id; // object对象
    objc_object **referrer = (objc_object **)referrer_id; // weak指针
    weak_entry_t *entry;

    if (!referent) return;
    if ((entry = weak_entry_for_referent(weak_table, referent))) { 
        remove_referrer(entry, referrer); // remove referrer // 移除弱引用指针
        bool empty = true;
        if (entry->out_of_line()  &&  entry->num_refs != 0) {
            empty = false;
        }
        else {
            for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
                if (entry->inline_referrers[i]) {
                    empty = false; 
                    break;
                }
            }
        }

        if (empty) {
            weak_entry_remove(weak_table, entry); // 移除entry
        }
    }
}
//先根据`object`对象和弱引用表获取`entry`，然后删除`weak`指针，最后再移除`entry`

弱引用表结构图

自动释放池(AutoreleasePool)

• 自动释放池是OC的一种内存自动回收机制，在MRC中可以用AutoReleasePool来延迟内存的释放，在ARC中可以用AutoReleasePool将对象添加到最近的自动释放池，不会立即释放，会等到runloop休眠或者超出autoreleasepool作用域{}之后才会被释放。可以通过下图来表示

在C++源码中@autoreleasepool是个__autoreleasepool的构造函数

struct __AtAutoreleasePool {
// 在构造函数时会调用`objc_autoreleasePoolPush`，
// 析构时调用`objc_autoreleasePoolPop`
  __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
  ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
  void * atautoreleasepoolobj;
};
// 源码比较类似都是调用`AutoreleasePoolPage`中的函数，一个是调用`push`，一个是调用`pop`
void *
objc_autoreleasePoolPush(void)
{
    return AutoreleasePoolPage::push();
}

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

AutoreleasePoolPage

• 通过描述：
  • 1.自动释放池是一个关于指针的栈结构
  • 2.其中的指针是指向释放的对象或者pool_boundary哨兵（现在经常被称为边界）
  • 3.自动释放池是一个页的结构，而且这个页是一个双向链表（表示有父节点和子节点，在类中提及过，即类的继承链）
  • 4.自动释放池和线程有关系

• 1.自动释放池是一个页，同时也是一个对象，这个页的大小是4096字节
• 2.从其定义中发现，AutoreleasePoolPage是继承自AutoreleasePoolPageData,且该类的属性也是来自父类，以下是AutoreleasePoolPageData的定义

• 其中有AutoreleasePoolPage对象，所以有以下一个关系链AutoreleasePoolPage -> AutoreleasePoolPageData -> AutoreleasePoolPage，从这里可以说明自动释放池除了是一个页，还是一个双向链表结构
• 1.其中AutoreleasePoolPageData结构体的内存大小为56字节
  • 属性magic的类型是magic_t结构体，所占内存大小为m[4];所占内存（即4*4=16字节）
  • 属性next（指针）、thread（对象）、parent（对象）、child（对象）均占8字节（即4*8=32字节）
  • 属性depth、hiwat类型为uint32_t，实际类型是unsigned int类型，均占4字节（即2*4=8字节） 通过上面可以知道一个空的AutoreleasePoolPage的结构如下：

• 首页结构图

objc_autoreleasePoolPush

如下

• 1.首先进行判断是否存在pool
• 2.如果没有，则通过autoreleaseNewPage方法创建
• 3.如果有，则通过autoreleaseFast压栈哨兵对象

autoreleaseNewPage创建页

• 通过上面的代码实现（autoreleaseFullPage后面会重点分析），我们知道一下结论

  • 1.判断当前页是否存在
  • 2.如果存在通过autoreleaseFullPage方法进行压栈对象
  • 3.如果不存在，则通过autoreleaseNoPage方法创建页
    • autoreleaseNoPage方法中可知当前线程的自动释放池是通过AutoreleasePoolPage创建的
    • AutoreleasePoolPage的构造方法是通过实现父类AutoreleasePoolPageData的初始化方法实现的

• 当前线程的自动释放池是通过AutoreleasePoolPage创建，看下AutoreleasePoolPage构造方法

其中AutoreleasePoolPageData方法传入的参数含义为：

• begin()表示压栈的位置（即下一个要释放对象的压栈地址）。可以通过源码调试begin，发现其具体实现等于页首地址+56，其中的56就是结构体AutoreleasePoolPageData的内存大小

AutoreleasePoolPage初始化

• objc_thread_self()是表示当前线程，而当前线程是通过tls获取
• newParent表示父节点
• 后续两个参数是通过父节点的深度、最大入栈个数计算depth以及hiwat

查看自动释放池内存结构

• 第一页可以存放504个对象，且只有第一页有哨兵，当一页压栈满了，就会开辟新的一页
• 第二页开始，最多可以存放505个对象
• 一页的大小等于505 * 8 = 4040
• AutoreleasePoolPage的SIZE是就说了，一页的大小为4096字节，而在其构造函数中对象的压栈位置，是从首地址+56开始的，所以可以一页中实际可以存储4096-56 = 4040字节，转换成对象是4040 / 8 = 505个,即一页最多可以存储505个对象，其中第一页有哨兵对象只能存储504个。其结构图如下：

总结

• autoreleasepool其本质是一个结构体对象，一个自动释放池对象就是页，是栈结构存储，符合先进后出的原则即可
• 页的栈底是一个56字节大小的空占位符，一页总大小为4096字节
• 只有第一页有哨兵对象，最多存储504个对象，从第二页开始最多存储505个对象
• autoreleasepool在加入要释放的对象时，底层调用的是objc_autoreleasePoolPush方法
• autoreleasepool在调用析构函数释放时，内部的实现是调用objc_autoreleasePoolPop方法

压栈对象 autoreleaseFast

• 获取当前操作页，并判断页是否存在以及是否满了
• 如果页存在，且未满，则通过add方法压栈对象
• 如果页存在，且满了，则通过autoreleaseFullPage方法安排新的页面
• 如果页不存在，则通过autoreleaseNoPage方法创建新页

autoreleaseFullPage 方法

这个方法主要是用于判断当前页是否已经存储满了，如果当前页已经满了，通过do-while循环查找子节点对应的页，如果不存在，则新建页，并压栈对象从上面AutoreleasePoolPage初始化方法中可以看出，主要是通过操作child对象，将当前页的child指向新建页面，由此可以得出页是通过双向链表连接。

add 方法

这个方法主要是添加释放对象，其底层是实现是通过next指针存储释放对象，并将next指针递增，表示下一个释放对象存储的位置。从这里可以看出页是通过栈结构存储

objc_autoreleasePoolPop

pop 方法

• 空页面的处理，并根据token获取page
• 容错处理
• 通过popPage出栈页

popPage

进入popPage源码，其中传入的allowDebug为false，则通过releaseUntil出栈当前页stop位置之前的所有对象，即向栈中的对象发送release消息，直到遇到传入的哨兵对象。

releaseUntil

• releaseUntil实现，主要是通过循环遍历，判断对象是否等于stop，其目的是释放stop之前的所有的对象
• 首先通过获取page的next释放对象（即page的最后一个对象），并对next进行递减，获取上一个对象
• 判断是否是哨兵对象，如果不是则自动调用objc_release释放

kill

通过kill实现我们知道，主要是销毁当前页，将当前页赋值为父节点页，并将父节点页的child对象指针置为nil

总结

通过上面的分析，针对自动释放池的push和pop，总结如下

• 在自动释放池的压栈（即push）操作中
  • 当没有pool，即只有空占位符（存储在tls中）时，则创建页，压栈哨兵对象
  • 在页中压栈普通对象主要是通过next指针递增进行的
  • 当页满了时，需要设置页的child对象为新建页
• objc_autoreleasePush的整体底层的流程

• 在自动释放池的出栈（即pop）操作中
  • 在页中出栈普通对象主要是通过next指针递减进行的，
  • 当页空了时，需要赋值页的parent对象为当前页
• objc_autoreleasePoolPop出栈的流程

面试题

临时变量什么时候释放？

• 如果在正常情况下，一般是超出其作用域就会立即释放
• 如果将临时变量加入了自动释放池，会延迟释放，即在runloop休眠或者autoreleasepool作用域之后释放

AutoreleasePool原理

• 自动释放池的本质是一个AutoreleasePoolPage结构体对象，是一个栈结构存储的页，每一个AutoreleasePoolPage都是以双向链表的形式连接
• 自动释放池的压栈和出栈主要是通过结构体的构造函数和析构函数调用底层的objc_autoreleasePoolPudh和objc_autoreleasePoolPop，实际上是调用AutoreleasePoolPage的push和pop两个方法
• 每次调用push操作其实就是创建一个新的AutoreleasePoolPage，而AutoreleasePoolPage的具体操作就是插入一个POOL_BOUNDARY，并返回插入POOL_BOUNDARY的内存地址。而push内部调用autoreleaseFast方法处理，主要有以下三种情况
  • 当page存在，且不满时，调用add方法将对象添加至page的next指针处，并next递增
  • 当page存在，且已满时，调用autoreleaseFullPage初始化一个新的page，然后调用add方法将对象添加至page栈中
  • 当page不存在时，调用autoreleaseNoPage创建一个hotPage，然后调用add方法将对象添加至page栈中
• 4.当执行pop操作时，会传入一个值，这个值就是push操作的返回值，即POOL_BOUNDARY的内存地址token。所以pop内部的实现就是根据token找到哨兵对象所处的page中，然后使用 objc_release释放token之前的对象，并把next指针到正确位置

AutoreleasePool能否嵌套使用？

• 可以嵌套使用，其目的是可以控制应用程序的内存峰值，使其不要太高
• 可以嵌套的原因是因为自动释放池是以栈为节点，通过双向链表的形式连接的，且是和线程一一对应的
• 自动释放池的多层嵌套其实就是不停的pushs哨兵对象，在pop时，会先释放里面的，在释放外面的

哪些对象可以加入AutoreleasePool？alloc创建可以吗？

• 在MRC下使用new、alloc、copy关键字生成的对象和retain了的对象需要手动释放，不会被添加到自动释放池中
• 在MRC下设置为autorelease的对象不需要手动释放，会直接进入自动释放池
• 所有autorelease的对象，在出了作用域之后，会被自动添加到最近创建的自动释放池中
• 在ARC下只需要关注引用计数，因为创建都是在主线程进行的，系统会自动为主线程创建AutoreleasePool，所以创建会自动放入自动释放池

AutoreleasePool的释放时机是什么时候？

• App启动后，苹果在主线程RunLoop里注册了两个Observer，其回调都是_wrapRunLoopWithAutoreleasePoolHandler()。
• 第一个Observer监视的事件是Entry(即将进入 Loop)，其回调内会调用 _objc_autoreleasePoolPush() 创建自动释放池。其order是-2147483647，优先级最高，保证创建释放池发生在其他所有回调之前。
• 第二个Observer监视了两个事件:BeforeWaiting(准备进入休眠) 时调用 _objc_autoreleasePoolPop()和_objc_autoreleasePoolPush()释放旧的池并创建新池；Exit(即 将退出Loop）时调用_objc_autoreleasePoolPop()来释放自动释放池。这个Observer的order是 2147483647，优先级最低，保证其释放池子发生在其他所有回调之后。

thread和AutoreleasePool的关系

• 每个线程，包括主线程在内都维护了自己的自动释放池堆栈结构
• 新的自动释放池在被创建时，会被添加到栈顶；当自动释放池销毁时，会从栈中移除
• 对于当前线程来说，会将自动释放的对象放入自动释放池的栈顶；在线程停止时，会自动释放掉与该线程关联的所有自动释放池
• 总结 ：每个线程都有与之关联的自动释放池堆栈结构，新的pool在创建时会被压栈到栈顶，pool销毁时，会被出栈，对于当前线程来说，释放对象会被压栈到栈顶，线程停止时，会自动释放与之关联的自动释放池

RunLoop和AutoreleasePool的关系

• 主程序的RunLoop在每次事件循环之前，会自动创建一个autoreleasePool
• 并且会在事件循环结束时，执行drain操作，释放其中的对象