精华内容
下载资源
问答
  • weak实现原理

    2020-03-24 18:33:36
    在ARC模式中weak关键字常常用来处理对象之间的互相强引用导致的内存泄漏问题,主要是因为使用weak修饰变量不会...定义weak实现文件 首先在Xcode中,打开汇编调试 Xcode->Debug->Debug Workflow->Always S...

    在ARC模式中weak关键字常常用来处理对象之间的互相强引用导致的内存泄漏问题,主要是因为使用weak修饰变量不会导致引用计数的增加不会影响对象的生命周期,而且在对象释放之后会将自动指针置空避免也指针访问问题.那么系统是和实现weak管理的?

    定位实现文件

    • 首先在Xcode中,打开汇编调试
    • Xcode->Debug->Debug Workflow->Always Show Disassembly
    • 创建对象并进行弱引用,并在弱引用处设置断点.
    • int main(int argc, const char * argv[]) {
          @autoreleasepool {
              NSObject *obj = [[NSObject alloc] init];
              __weak typeof(obj) weakObj = obj;//在此处断点
          }
      }
    • 执行
    • ...
      0x100000ece <+62>:  movq   %rax, -0x18(%rbp)
      ->  0x100000ed2 <+66>:  movq   -0x18(%rbp), %rax
          0x100000ed6 <+70>:  leaq   -0x20(%rbp), %rsi
          0x100000eda <+74>:  movq   %rsi, %rdi
          0x100000edd <+77>:  movq   %rax, %rsi
          0x100000ee0 <+80>:  callq  0x100000f2e               ; symbol stub for: objc_initWeak
          0x100000ee5 <+85>:  leaq   -0x20(%rbp), %rsi
          0x100000ee9 <+89>:  movq   %rsi, %rdi
          0x100000eec <+92>:  movq   %rax, -0x30(%rbp)
          0x100000ef0 <+96>:  callq  0x100000f28               ; symbol stub for: objc_destroyWeak
          0x100000ef5 <+101>: xorl   %ecx, %ecx
          0x100000ef7 <+103>: movl   %ecx, %esi
          0x100000ef9 <+105>: leaq   -0x18(%rbp), %rax
          0x100000efd <+109>: movq   %rax, %rdi
          0x100000f00 <+112>: callq  0x100000f34               ; symbol stub for: objc_storeStrong
          0x100000f05 <+117>: movq   -0x28(%rbp), %rdi
          0x100000f09 <+121>: callq  0x100000f1c               ; symbol stub for: objc_autoreleasePoolPop
          0x100000f0e <+126>: xorl   %eax, %eax
          0x100000f10 <+128>: addq   $0x30, %rsp
          0x100000f14 <+132>: popq   %rbp
          0x100000f15 <+133>: retq   
      
    • 发现下一步要执行的函数是objc_initWeak,为符号objc_initWeak设置断点
    • Xcode->Show the Breakpoint navigator->左下角 "+" ->Symbolic Breakpoint...
    • 发现在objc_initWeak函数的实现在libobjc.A.dylib中
    • libobjc.A.dylib`::objc_initWeak(id *, id):
          0x1003c6c40 <+0>:  pushq  %rbp
          0x1003c6c41 <+1>:  movq   %rsp, %rbp
          0x1003c6c44 <+4>:  subq   $0x20, %rsp
          0x1003c6c48 <+8>:  movq   %rdi, -0x10(%rbp)
          0x1003c6c4c <+12>: movq   %rsi, -0x18(%rbp)
      ->  0x1003c6c50 <+16>: cmpq   $0x0, -0x18(%rbp)
          0x1003c6c55 <+21>: jne    0x1003c6c73               ; <+51> at NSObject.mm:415:10
          0x1003c6c5b <+27>: movq   -0x10(%rbp), %rax
          0x1003c6c5f <+31>: movq   $0x0, (%rax)
          0x1003c6c66 <+38>: movq   $0x0, -0x8(%rbp)
          0x1003c6c6e <+46>: jmp    0x1003c6c87               ; <+71> at NSObject.mm:416:1
      ...

    所以可以通过objc的源代码来查找相关实现.

    查看实现

    以下探讨使用objc756.2进行说明.

    首先了解需要的数据结构

    • StripedMap

      • reinterpret_cast<new_type> (expression)是C++中用来处理无关类型转化的一个运算符,它会产生一个新的值,这个值会有与原始参数有完全相同的比特位.在该实现中用于将一个证书类型转化为指针类型,可以理解为生成一个开辟置顶大小空间的指针;
    • 使用场景:
      
      从指针类型到一个足够大的整数类型
      从整数类型或者枚举类型到指针类型
      从一个指向函数的指针到另一个不同类型的指向函数的指针
      从一个指向对象的指针到另一个不同类型的指向对象的指针
      从一个指向类函数成员的指针到另一个指向不同类型的函数成员的指针
      从一个指向类数据成员的指针到另一个指向不同类型的数据成员的指针

       

      • 全局维护了一个StripedMap变量,其内部实现是一个静态数组.在TARGET_OS_IPHONE非模拟器上数组元素的最大个数为8,否则数组元素的最大个数为64.
      • 通过将被引用对象的地址做indexForPointer运算使得每个被引用对象运算之后的结果在[0, StripeCount)之间;
      • 存储的值是抽象的PaddedT,在弱引用管理中存储的是结构体SideTable的实例.
    • static StripedMap<SideTable>& SideTables() {
          return *reinterpret_cast<StripedMap<SideTable>*>(SideTableBuf);
      }
      
      
      class StripedMap {
      #if TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR
          enum { StripeCount = 8 };
      #else
          enum { StripeCount = 64 };
      #endif
      
          
          struct PaddedT {
              T value alignas(CacheLineSize);
          };
      
          PaddedT array[StripeCount];
          int count = StripeCount;
      
          //将被引用对象的指针索引化,结果在[0, StripeCount)
          static unsigned int indexForPointer(const void *p) {
              uintptr_t addr = reinterpret_cast<uintptr_t>(p);
              int count = StripeCount;
              return ((addr >> 4) ^ (addr >> 9)) % StripeCount;
          }
      
       public:
          T& operator[] (const void *p) { 
              return array[indexForPointer(p)].value; 
          }
          const T& operator[] (const void *p) const { 
              return const_cast<StripedMap<T>>(this)[p]; 
          }
      
          // Shortcuts for StripedMaps of locks.
          void lockAll() {
              for (unsigned int i = 0; i < StripeCount; i++) {
                  array[i].value.lock();
              }
          }
      
          void unlockAll() {
              for (unsigned int i = 0; i < StripeCount; i++) {
                  array[i].value.unlock();
              }
          }
      
          void forceResetAll() {
              for (unsigned int i = 0; i < StripeCount; i++) {
                  array[i].value.forceReset();
              }
          }
      
          void defineLockOrder() {
              for (unsigned int i = 1; i < StripeCount; i++) {
                  lockdebug_lock_precedes_lock(&array[i-1].value, &array[i].value);
              }
          }
      
          void precedeLock(const void *newlock) {
              // assumes defineLockOrder is also called
              lockdebug_lock_precedes_lock(&array[StripeCount-1].value, newlock);
          }
      
          void succeedLock(const void *oldlock) {
              // assumes defineLockOrder is also called
              lockdebug_lock_precedes_lock(oldlock, &array[0].value);
          }
      
          const void *getLock(int i) {
              if (i < StripeCount) return &array[i].value;
              else return nil;
          }
          
      #if DEBUG
          StripedMap() {
              // Verify alignment expectations.
              uintptr_t base = (uintptr_t)&array[0].value;
              uintptr_t delta = (uintptr_t)&array[1].value - base;
              assert(delta % CacheLineSize == 0);
              assert(base % CacheLineSize == 0);
          }
      #else
          constexpr StripedMap() {}
      #endif
      };
    • SideTable:主要用于辅助管理对象的引用计数和弱引用依赖.
      • slock:保证操作线程安全的自旋锁;
      • 用于辅助管理对象的引用计数:当对象isa中extra_rc不足以存储对象引用对象时,has_sidetable_rc会被置为1,然后对引用计数进行折半,一半存储在isa中extra_rc位区,另一半存储在对应的sidetable中,可以通过对象的地址查找到存储的sidetable实例.
    • ​struct SideTable {
          spinlock_t slock; //保障操作安全的锁
          RefcountMap refcnts;//保存对应的引用计数:当isa中extra_rc不足以保存时,使用散列表保存refcnts.find(obj)
          weak_table_t weak_table;//保存weak_table_t
      
          //默认构造函数
          SideTable() {
              memset(&weak_table, 0, sizeof(weak_table));
          }
          
          //析构函数
          ~SideTable() {
              _objc_fatal("Do not delete SideTable.");
          }
      
          void lock() { slock.lock(); }
          void unlock() { slock.unlock(); }
          void forceReset() { slock.forceReset(); }
      
          // Address-ordered lock discipline for a pair of side tables.
      
          template<HaveOld, HaveNew>
          static void lockTwo(SideTable *lock1, SideTable *lock2);
          template<HaveOld, HaveNew>
          static void unlockTwo(SideTable *lock1, SideTable *lock2);
      };
      
    • struct weak_table_t:全局的弱引用表,所有的弱引用都在该表中进行存储,使用不定类型对象的地址作为 key,用 weak_entry_t 类型结构体对象作为 value 
    • /**
       * The global weak references table. Stores object ids as keys,
       * and weak_entry_t structs as their values.
       */
      struct weak_table_t {
          weak_entry_t *weak_entries; //保存了所有指向指定对象的weak指针
          size_t    num_entries; // weak对象的存储空间大小
          uintptr_t mask;参与判断引用计数辅助量
          uintptr_t max_hash_displacement;//hash key 最大偏移值:hash冲撞时最大尝试次数,用于优化搜索算法
      };
      
    • struct weak_entry_t:用来存储具体某一对象的所有弱引用指针
      • 当对象的弱引用指针小于4个时,使用静态数组inline_referrers进行保存,同时out_of_line_ness = 0;
      • 当对象弱引用指针大于4个时,使用二维数组referrers保存,out_of_line_ness = 2;
    • struct weak_entry_t {
          DisguisedPtr<objc_object> referent;
          union {
              //当弱引用指针个数大于WEAK_INLINE_COUNT时,使用二维指针进行存储
              struct {
                  weak_referrer_t *referrers;
                  uintptr_t        out_of_line_ness : 2;
                  uintptr_t        num_refs : PTR_MINUS_2;
                  uintptr_t        mask;
                  uintptr_t        max_hash_displacement;
              };
      
              //当弱引用指针个数小于WEAK_INLINE_COUNT时,使用一位数组进行存储
              struct {
                  // out_of_line_ness field is low bits of inline_referrers[1]
                  weak_referrer_t  inline_referrers[WEAK_INLINE_COUNT];
              };
          };
          //判断当前是否是离线存储
          bool out_of_line() {
              return (out_of_line_ness == REFERRERS_OUT_OF_LINE);
          }
          //重载运算符=
          weak_entry_t& operator=(const weak_entry_t& other) {
              memcpy(this, &other, sizeof(other));
              return *this;
          }
          //第一个弱引用指针使用该方法存储
          weak_entry_t(objc_object *newReferent, objc_object **newReferrer)
              : referent(newReferent)
          {
              inline_referrers[0] = newReferrer;
              for (int i = 1; i < WEAK_INLINE_COUNT; i++) {
                  inline_referrers[i] = nil;
              }
          }
      };

     

    实现原理

    在NSObject.mm(line 406-426)中找到了相关实现.

    • objc_initWeak:runtime会调用objc_initWeak函数,初始化一个新的weak指针指向对象的地址;
    • 
      objc_initWeak(id *location, id newObj)
      {
          //判断原始引用对象是否为空;
          if (!newObj) {
              *location = nil;
              return nil;
          }
          // 这里传递了三个 bool 数值
          // 使用 template 进行常量参数传递是为了优化性能,预判了大概率会发生的事情处理优先
          return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
              (location, (objc_object*)newObj);
      }
    • storeWeak函数:objc_initWeak函数会调用 objc_storeWeak() 函数, objc_storeWeak() 的作用是更新指针指向,创建对应的弱引用表。
    • static id 
      storeWeak(id *location, objc_object *newObj)
      {
             //断言在模板参数中新值和旧值至少有一个是存在:这个参数只是表明我觉得很大可能是有(新值/旧值)或者没有(新值/旧值),实际上有或者没有还是要做具体判断
             assert(haveOld  ||  haveNew);
             if (!haveNew) assert(newObj == nil);
             //在类没有完成+initialized方法之前调用weakStore时,作为初始化的标识
             Class previouslyInitializedClass = nil;
             id oldObj;
             SideTable *oldTable;
             SideTable *newTable;
      
             // Acquire locks for old and new values.
             // Order by lock address to prevent lock ordering problems.
             // Retry if the old value changes underneath us.
          //定义代码块,供关键字goto使用
          retry:
             if (haveOld) {
                 //获取弱引用指针的旧指向
                 oldObj = *location;
                  //获取oldObj对应的弱引用表
                 oldTable = &SideTables()[oldObj];
             } else {
                 oldTable = nil;
             }
             if (haveNew) {
              //获取newObj对应的弱引用表
                 newTable = &SideTables()[newObj];
             } else {
                 newTable = nil;
             }
      
      
          SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);
      
          //location存在弱引用指向
          if (haveOld  &&  *location != oldObj) {
              SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
              goto retry;
          }
      
          // Prevent a deadlock between the weak reference machinery
          // and the +initialize machinery by ensuring that no 
          // weakly-referenced object has an un-+initialized isa.
          //主要防止在自定义的+initialize方法未完成时,调用storeWeak方法形成死锁(例如在+initialize添加弱引用)
          if (haveNew  &&  newObj) {
              Class cls = newObj->getIsa();
              if (cls != previouslyInitializedClass  &&  
                  !((objc_class *)cls)->isInitialized()) 
              {
                  SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
                  class_initialize(cls, (id)newObj);
      
                  // If this class is finished with +initialize then we're good.
                  // If this class is still running +initialize on this thread 
                  // (i.e. +initialize called storeWeak on an instance of itself)
                  // then we may proceed but it will appear initializing and 
                  // not yet initialized to the check above.
                  // Instead set previouslyInitializedClass to recognize it on retry.
                  previouslyInitializedClass = cls;
      
                  goto retry;
              }
          }
      
          // Clean up old value, if any.
          //如果旧值存在就清理旧值
          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);
              // weak_register_no_lock returns nil if weak store should be rejected
      
              // Set is-weakly-referenced bit in refcount table.
              if (newObj  &&  !newObj->isTaggedPointer()) {
                  newObj->setWeaklyReferenced_nolock();
              }
      
              // Do not set *location anywhere else. That would introduce a race.
              *location = (id)newObj;
          }
          else {
              // No new value. The storage is not changed.
          }
          
          SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
      
          return (id)newObj;
      }

    绑定存储

    • weak_register_no_lock:向指定的弱引用表weak_table中添加新的弱应用指针.
      • 如果被引用对象referent为空或者referent是标签指针则直接返回referent_id;
      • 判断当前对象是否正在释放.如果当前对象正在释放,当crashIfDeallocating=true,则抛出异常;当crashIfDeallocating=false时直接返回nil。通过这个函数,还可以得到一个意外的知识点:在自定义的dealloc实现中,不允许增加新的弱引用指针,否则会报错.通过这个函数可以知道在自定义的dealloc实现中,不允许增加新的弱引用指针,否则会报错.
      • 判断当前的弱引用表中是否存在referent对应的weak_entry_t:如果存在则直接进行append_referrer,否则需要创建新的weak_entry_t实例并添加到当前的弱应用表中.
    • id 
      weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                            id *referrer_id, bool crashIfDeallocating)
      {
          //获取被引用对象
          objc_object *referent = (objc_object *)referent_id;
          //强转referrer_id为二级指针
          objc_object **referrer = (objc_object **)referrer_id;
      
          //如果被引用对象不存在或者被引用对象为TaggedPointer(标签指针),直接返回被引用对象的指针
          if (!referent  ||  referent->isTaggedPointer()) return referent_id;
      
          // ensure that the referenced object is viable
          bool deallocating;
          
          /*
           查看是否有自定义的RR函数,RR函数包括:
           retain
           release
           autorelease
           retainCount
           tryRetain
           SEL_retainWeakReference
           isDeallocating
           allowsWeakReference);
           */
          if (!referent->ISA()->hasCustomRR()) {
      
              deallocating = referent->rootIsDeallocating();
          }
          else {
              BOOL (*allowsWeakReference)(objc_object *, SEL) = 
                  (BOOL(*)(objc_object *, SEL))
                  object_getMethodImplementation((id)referent, 
                                                 SEL_allowsWeakReference);
              if ((IMP)allowsWeakReference == _objc_msgForward) {
                  return nil;
              }
              deallocating =
                  ! (*allowsWeakReference)(referent, SEL_allowsWeakReference);
          }
      
          if (deallocating) {
              //如果对象正在释放,不能增加新的弱引用指针
              if (crashIfDeallocating) {
                  _objc_fatal("Cannot form weak reference to instance (%p) of "
                              "class %s. It is possible that this object was "
                              "over-released, or is in the process of deallocation.",
                              (void*)referent, object_getClassName((id)referent));
              } else {
                  return nil;
              }
          }
      
          // now remember it and where it is being stored
          weak_entry_t *entry;
          if ((entry = weak_entry_for_referent(weak_table, referent))) {
              //在weak_table找到referent对应的weak_entry_t
              append_referrer(entry, referrer); //在entry中添加新的弱引用指针referrer
          } 
          else {
              //在weak_table中未找到referent对应的weak_entry_t
              weak_entry_t new_entry(referent, referrer); //初始化新的weak_entry_t
              weak_grow_maybe(weak_table); //查看是否需要重新开辟weak_table空间
              weak_entry_insert(weak_table, &new_entry); //在weak_table中插入new_entry
          }
      
          // Do not set *referrer. objc_storeWeak() requires that the 
          // value not change.
      
          return referent_id;
      }
    • weak_grow_maybe:尝试增加弱引用表的容量.
      • 若weaktable当前的使用量不小于总量的3/4,则进行扩容;否则不做任何处理.同时也可以看出弱引用表中容量的初始化值为64.
    • static void weak_grow_maybe(weak_table_t *weak_table)
      {
          size_t old_size = TABLE_SIZE(weak_table);
      
          // Grow if at least 3/4 full.
          if (weak_table->num_entries >= old_size * 3 / 4) {
              //扩容之后开辟新的空间并复制
              weak_resize(weak_table, old_size ? old_size*2 : 64);
          }
      }
      

       

    • weak_entry_insert:向弱引用表中插入新的entry.
      • 使用hash_pointer(new_entry->referent) & (weak_table->mask)获取起始索引;
      • 循环查找weak_entries中为空的位置;
      • 在index位置保存new_entry并num_entries进行自增;
      • 保存哈希碰撞最大的尝试次数,在查找时可以减少搜索次数.
    • static void weak_entry_insert(weak_table_t *weak_table, weak_entry_t *new_entry)
      {
          weak_entry_t *weak_entries = weak_table->weak_entries;
          assert(weak_entries != nil);
      
          //使用hash_pointer对new_entry->referent进行哈希运算并对容量取与
          size_t begin = hash_pointer(new_entry->referent) & (weak_table->mask);
          size_t index = begin;
          size_t hash_displacement = 0;
          while (weak_entries[index].referent != nil) {
              index = (index+1) & weak_table->mask;
              if (index == begin) bad_weak_table(weak_entries);
              //hash碰撞hash_displacement自增
              hash_displacement++;
          }
          //获取到哈希索引保存new_entry
          weak_entries[index] = *new_entry;
          //weak_table->num_entries自增
          weak_table->num_entries++;
      
          if (hash_displacement > weak_table->max_hash_displacement) {
              //保存哈希碰撞最大尝试次数,由于优化搜索算法减少搜索次数
              weak_table->max_hash_displacement = hash_displacement;
          }
      }
      

       

    • append_referrer: 在weak_entry_t中添加新的弱引用指针.
      • 当前没有使用离线存储,遍历内部静态数组inline_referrers,有空余的位置则直接保存new_referrer;否则开辟新的空间指针new_referrers,并将原始静态数组的元素复制到新开辟空间中的对应位置,然后重置entry相关属性(此时entry->num_refs=WEAK_INLINE_COUNT是大于TABLE_SIZE(entry) * 3/4).
      • 判断离线存储的实际使用量(num_refs)是否大于空间总量的(TABLESIZE(entry)),如果为真则需要扩容并添加新的弱引用指针,直接返回grow_refs_and_insert;否则正常存储.
    • static void append_referrer(weak_entry_t *entry, objc_object **new_referrer)
      {
          //在增加新的弱引用指针之前使用非离线存储弱引用指针:使用静态数组inline_referrers来进行存储
          if (! entry->out_of_line()) {
              //遍历inline_referrers查看是否存在空的位置
              for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
                  if (entry->inline_referrers[i] == nil) {
                      //存在则直接将新的弱引用指针存储在该位置,并返回
                      entry->inline_referrers[i] = new_referrer;
                      return;
                  }
              }
      
              // 在静态数组中没有可用的存储位置,需要开辟离线空间
              weak_referrer_t *new_referrers = (weak_referrer_t *)
                  calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t));
              //将之前使用静态数组进行存储的元素复制到新的new_referrers中,虽然目前来讲这部分操作并没开辟足够的空间存储新的new_referrer,但是不用紧张会在grow_refs_and_inser进行修复并对元素进行哈希
              for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
                  new_referrers[i] = entry->inline_referrers[i];
              }
              entry->referrers = new_referrers;
              entry->num_refs = WEAK_INLINE_COUNT;
              entry->out_of_line_ness = REFERRERS_OUT_OF_LINE;
              entry->mask = WEAK_INLINE_COUNT-1;//entry->mask永远是最大容量-1
              entry->max_hash_displacement = 0; //重置max_hash_displacement
          }
          //断言:代码执行到这个位置时entry应该是离线存储,即:entry->out_of_line() = true
          assert(entry->out_of_line());
      
          //如果当前已经使用了总量的3/4,则l扩容并添加新的引用,并返回
          if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) {
              return grow_refs_and_insert(entry, new_referrer);
          }
          //如果当前已经使用量小于总量的3/4,则直接添加 
          size_t begin = w_hash_pointer(new_referrer) & (entry->mask); //hash new_referrer并与entry->mask作&运算得到起始索引
          size_t index = begin;
          size_t hash_displacement = 0;
          //发生hash碰撞
          while (entry->referrers[index] != nil) {
              hash_displacement++;
              index = (index+1) & entry->mask;
              if (index == begin) bad_weak_table(entry);
          }
          //更新存储时最大的hash碰撞次数,由于优化取值时算法减少搜索次数
          if (hash_displacement > entry->max_hash_displacement) {
              entry->max_hash_displacement = hash_displacement;
          }
          weak_referrer_t &ref = entry->referrers[index];
          ref = new_referrer;
          entry->num_refs++;
      }
    • grow_refs_and_insert:扩容并增加新的弱引用指针,最终的存储还是依靠append_referrer完成.
      • 如果当前entry容量为0则初始化new_size=8;否则置new_size=2*old_size;
      • 开辟新的空间指针赋值给entry->referrers并重置entry相关属性;
      • 插入新的弱引用指针.
    • __attribute__((noinline, used))
      static void grow_refs_and_insert(weak_entry_t *entry, 
                                       objc_object **new_referrer)
      {
          assert(entry->out_of_line());
          //获取当前的entry容量
          size_t old_size = TABLE_SIZE(entry);
          //如果当前容量为0则置new_size = 8;否则new_size=2*old_size;
          size_t new_size = old_size ? old_size * 2 : 8;
      
          size_t num_refs = entry->num_refs;
          weak_referrer_t *old_refs = entry->referrers;
          //重置entry->mask
          entry->mask = new_size - 1;
          //开辟新的空间指针进行扩容
          entry->referrers = (weak_referrer_t *)
              calloc(TABLE_SIZE(entry), sizeof(weak_referrer_t));
          entry->num_refs = 0;
          entry->max_hash_displacement = 0;
          
          for (size_t i = 0; i < old_size && num_refs > 0; i++) {
              if (old_refs[i] != nil) {
                  append_referrer(entry, old_refs[i]);
                  num_refs--;
              }
          }
          // Insert
          append_referrer(entry, new_referrer);
          //释放旧指针空间
          if (old_refs) free(old_refs);
      }
      
    • setWeaklyReferenced_nolock:保存对象的弱引用标记
      • 判断是否支持nonpointer,若不支持则直接在sidetable中保存弱引用标记;否则继续执行.
      • 若支持nonpointer且已经被标记为存在弱引用指针,则直接返回;否则继续执行.
      • 在isa中保存弱引用标记;
      • 进行newisa保存.

     

    inline void
    objc_object::setWeaklyReferenced_nolock()
    {
     retry:
        isa_t oldisa = LoadExclusive(&isa.bits);
        isa_t newisa = oldisa;
        //若当前对象不支持nonpointer
        if (slowpath(!newisa.nonpointer)) {
            ClearExclusive(&isa.bits);
            //在弱引用表中存储弱引用标志
            sidetable_setWeaklyReferenced_nolock();
            return;
        }
        //当前对象支持nonpointer且已经被标识为弱引用
        if (newisa.weakly_referenced) {
            ClearExclusive(&isa.bits);
            return;
        }
        //当前对象支持nonpointer,则添加弱引用标记
        newisa.weakly_referenced = true;
        //保存弱引用标记
        if (!StoreExclusive(&isa.bits, oldisa.bits, newisa.bits)) goto retry;
    }

    解除存储

    • weak_unregister_no_lock:移除指定的弱引用指针
      • 在weak_table中查找对应的entry;
      • 从entry中移除referrer,并判断移除之后entry是否为空;
      • 若移除之后当前entry为空,则从weak_table中移除entry.
    void
    weak_unregister_no_lock(weak_table_t *weak_table, id referent_id, 
                            id *referrer_id)
    {
        //获取被引用对象
        objc_object *referent = (objc_object *)referent_id;
        //强转referrer_id为二级指针
        objc_object **referrer = (objc_object **)referrer_id;
    
        weak_entry_t *entry;
    
        if (!referent) return;
        //获取weak_table_t中的weak_entry_t *weak_entries;
        if ((entry = weak_entry_for_referent(weak_table, referent))) {
            //如果弱引用指针存在,则从entry移除referrer
            remove_referrer(entry, referrer);
            bool empty = true;//判断移除referrer之后entry是否为空
            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;
                    }
                }
            }
            //如果移除referrer之后entry为空则从表中移除entry
            if (empty) {
                weak_entry_remove(weak_table, entry);
            }
        }
    
        // Do not set *referrer = nil. objc_storeWeak() requires that the 
        // value not change.
    }
    • remove_referrer: 从当前weak_entry_t实例中移除弱引用指针.
      • 判断是否是弱引用是否是离线存储:如果使用飞离线存储,则遍历inline_referrers查找old_referrer,查找到则置空,否则只需执行;
      • 使用离线存储机制:使用 w_hash_pointer(old_referrer) & (entry->mask)获取起始索引,遍历entry->referrers,找到之后置空,并entry->num_refs自减.
    static void remove_referrer(weak_entry_t *entry, objc_object **old_referrer)
    {
        
        //如果entry没有使用离线机制存储:对象弱引用个数不大于WEAK_INLINE_COUNT
        if (! entry->out_of_line()) {
            for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
                if (entry->inline_referrers[i] == old_referrer) {
                    //置空对应的弱引用指针
                    entry->inline_referrers[i] = nil;
                    return;
                }
            }
            _objc_inform("Attempted to unregister unknown __weak variable "
                         "at %p. This is probably incorrect use of "
                         "objc_storeWeak() and objc_loadWeak(). "
                         "Break on objc_weak_error to debug.\n", 
                         old_referrer);
            objc_weak_error();
            return;
        }
        //如果entry使用离线机制存储:对象弱引用个数大于WEAK_INLINE_COUNT
        size_t begin = w_hash_pointer(old_referrer) & (entry->mask);
        size_t index = begin;
        size_t hash_displacement = 0;
        while (entry->referrers[index] != old_referrer) {
            index = (index+1) & entry->mask;
            if (index == begin) bad_weak_table(entry);
            //搜索次数+1
            hash_displacement++;
            if (hash_displacement > entry->max_hash_displacement) {
                _objc_inform("Attempted to unregister unknown __weak variable "
                             "at %p. This is probably incorrect use of "
                             "objc_storeWeak() and objc_loadWeak(). "
                             "Break on objc_weak_error to debug.\n", 
                             old_referrer);
                objc_weak_error();
                return;
            }
        }
        //将index对应的referrer置空
        entry->referrers[index] = nil;
        //弱引用计数-1
        entry->num_refs--;
    }

    对象释放

    使用weak一个最重要的特性就是在对象释放时,指向对象的所有弱引用都会被自动置为nil,从而可以有效滴防止非法访问造成的也指针问题.当一个对象的引用计数为零时,对象会进行释放销毁,调用过程大概这个样子:

    • 在对象释放时会调用dealloc方法,而dealloc会调用_objc_rootDealloc方法:
    // Replaced by NSZombies
    - (void)dealloc {
        _objc_rootDealloc(self);
    }
    
    
    • _objc_rootDealloc调用objc->rootDealloc:
    inline void
    objc_object::rootDealloc()
    {
        if (isTaggedPointer()) return;  // fixme necessary?
    
        if (fastpath(isa.nonpointer  &&  
                     !isa.weakly_referenced  &&  
                     !isa.has_assoc  &&  
                     !isa.has_cxx_dtor  &&  
                     !isa.has_sidetable_rc))
        {
            assert(!sidetable_present());
            free(this);
        } 
        else {
            object_dispose((id)this);
        }
    }
    • objc->rootDealloc调用objc_dispose:
    /***********************************************************************
    * object_dispose
    * fixme
    * Locking: none
    **********************************************************************/
    id 
    object_dispose(id obj)
    {
        if (!obj) return nil;
    
        objc_destructInstance(obj);    
        free(obj);
    
        return nil;
    }
    
    • objc-dispose调用objc_destructInstance:
    /***********************************************************************
    * objc_destructInstance
    * Destroys an instance without freeing memory. 
    * Calls C++ destructors.
    * Calls ARC ivar cleanup.
    * Removes associative references.
    * Returns `obj`. Does nothing if `obj` is nil.
    **********************************************************************/
    void *objc_destructInstance(id obj) 
    {
        if (obj) {
            // Read all of the flags at once for performance.
            bool cxx = obj->hasCxxDtor();
            bool assoc = obj->hasAssociatedObjects();
    
            // This order is important.
            if (cxx) object_cxxDestruct(obj);
            if (assoc) _object_remove_assocations(obj);
            obj->clearDeallocating();
        }
    
        return obj;
    }
    
    
    • objc_desctructInstance调用objc->clearDeallocating:
    
    inline void 
    objc_object::clearDeallocating()
    {
        //若果不支持nonpointer技术,则直接释放
        if (slowpath(!isa.nonpointer)) {
            // Slow path for raw pointer isa.
            sidetable_clearDeallocating();
        }
        else if (slowpath(isa.weakly_referenced  ||  isa.has_sidetable_rc)) {
        //支持nonpointer&有弱引用指针&(弱引用指针 || 引用计数存储在弱引用表中)
            // Slow path for non-pointer isa with weak refs and/or side table data.
            clearDeallocating_slow();
        }
    
        assert(!sidetable_present());
    }
    
    • 如果当前对象不支持nonpointer则执行sidetable_clearDeallocating;否则当前对象存在弱引用指针或者引用计数存在弱引用表中,则执行clearDeallocating_slow.
      • sidetable_clearDeallocating:当前对象不支持nonpointer时,清除sidetable中的弱引用指针以及引用计数:此时是否存在弱引用指针的标志存储在RefcountMap::iterator中的成员变量second中.
    • void 
      objc_object::sidetable_clearDeallocating()
      {
          SideTable& table = SideTables()[this];
      
          // clear any weak table items
          // clear extra retain count and deallocating bit
          // (fixme warn or abort if extra retain count == 0 ?)
          //添加线程锁
          table.lock();
          RefcountMap::iterator it = table.refcnts.find(this);
          if (it != table.refcnts.end()) {
              //清除弱引用表
              if (it->second & SIDE_TABLE_WEAKLY_REFERENCED) {
                  weak_clear_no_lock(&table.weak_table, (id)this);
              }
              //清除引用计数
              table.refcnts.erase(it);
          }
          table.unlock();
      }
      • clearDeallocating_slow:当前对象支持nonpointer时,清除弱引用指针以及引用计数:此时是否存在弱引用的标志存储在isa的weakly_referenced位域中.
    • NEVER_INLINE void
      objc_object::clearDeallocating_slow()
      {
          assert(isa.nonpointer  &&  (isa.weakly_referenced || isa.has_sidetable_rc));
      
          SideTable& table = SideTables()[this];
          table.lock();
          if (isa.weakly_referenced) {
              //清除弱引用表
              weak_clear_no_lock(&table.weak_table, (id)this);
          }
          if (isa.has_sidetable_rc) {
              //清除引用计数
              table.refcnts.erase(this);
          }
          table.unlock();
      }
      
    • weak_clear_no_lock:清理指向referent的弱引用指针.
    /** 
     * Called by dealloc; nils out all weak pointers that point to the 
     * provided object so that they can no longer be used.
     * 
     * @param weak_table 
     * @param referent The object being deallocated. 
     */
    void 
    weak_clear_no_lock(weak_table_t *weak_table, id referent_id) 
    {
        objc_object *referent = (objc_object *)referent_id;
    
        weak_entry_t *entry = weak_entry_for_referent(weak_table, referent);
        //若entry为空则证明当前对象不存在弱引用指针.
        if (entry == nil) {
            /// XXX shouldn't happen, but does with mismatched CF/objc
            //printf("XXX no entry for clear deallocating %p\n", referent);
            return;
        }
    
        // zero out references
        weak_referrer_t *referrers;
        size_t count;
        
        
        if (entry->out_of_line()) {
            //使用离线存储弱引用指针
            referrers = entry->referrers;
            count = TABLE_SIZE(entry);
        } 
        else {
            //使用内部静态数组存储弱引用指针
            referrers = entry->inline_referrers;
            count = WEAK_INLINE_COUNT;
        }
        //遍历弱引用数组逐个置空指向referent的弱引用指针
        for (size_t i = 0; i < count; ++i) {
            objc_object **referrer = referrers[i];
            if (referrer) {
                //当前弱指针指向对象referent
                if (*referrer == referent) {
                    //置空弱引用指针
                    *referrer = nil;
                }
                else if (*referrer) {
                    _objc_inform("__weak variable at %p holds %p instead of %p. "
                                 "This is probably incorrect use of "
                                 "objc_storeWeak() and objc_loadWeak(). "
                                 "Break on objc_weak_error to debug.\n", 
                                 referrer, (void*)*referrer, (void*)referent);
                    objc_weak_error();
                }
            }
        }
        
        //从weak_table中移除entry
        weak_entry_remove(weak_table, entry);
    }
    

     

    总结

    • entry存储使用了hash_pointer,referrer存储使用了w_hash_pointer,其实两个函数的实现是一样的.

    static inline uintptr_t hash_pointer(objc_object *key) {
        return ptr_hash((uintptr_t)key);
    }
    
    static inline uintptr_t w_hash_pointer(objc_object **key) {
        return ptr_hash((uintptr_t)key);
    }
    • 全局的SideTables()方法获取的其实是一个StripedMap<SideTable>*类型的对象,该对象内部创建了一个最大容量为StripeCount(在iOS真机中StripeCount=8;iOS模拟器中StripeCount=64)的静态数组,所有的对象都通过indexForPointer函数映射到[0,StripeCount)的索引位置进行存储;
    • weak_table_t中weak_entries数量的初始化数量mask是64
    static void weak_grow_maybe(weak_table_t *weak_table)
    {
        size_t old_size = TABLE_SIZE(weak_table);
    
        // Grow if at least 3/4 full.
        if (weak_table->num_entries >= old_size * 3 / 4) {
            weak_resize(weak_table, old_size ? old_size*2 : 64);
        }
    }
    • weak_entry_t中referrers的初始化数量mask是8
    __attribute__((noinline, used))
    static void grow_refs_and_insert(weak_entry_t *entry, 
                                     objc_object **new_referrer)
    {
        assert(entry->out_of_line());
    
        size_t old_size = TABLE_SIZE(entry);
        size_t new_size = old_size ? old_size * 2 : 8;
    
        size_t num_refs = entry->num_refs;
        weak_referrer_t *old_refs = entry->referrers;
        entry->mask = new_size - 1;
        ...
    }
    
    • weak_table_t和weak_entry_t都是在使用量超过总量3/4时开始扩容
    //weak_table_t扩容
    static void weak_grow_maybe(weak_table_t *weak_table)
    {
        size_t old_size = TABLE_SIZE(weak_table);
    
        // Grow if at least 3/4 full.
        if (weak_table->num_entries >= old_size * 3 / 4) {
            weak_resize(weak_table, old_size ? old_size*2 : 64);
        }
    }
    
    
    
    
    //weak_entry_t进行扩容
    static void append_referrer(weak_entry_t *entry, objc_object **new_referrer)
    {
        ...
        //如果当前已经使用了总量的3/4,则扩容并添加新的引用,并返回
        if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) {
            return grow_refs_and_insert(entry, new_referrer);
        }
        ...
    }
    

     

    展开全文
  • 基本上每一个面试都会问weak实现原理,还有循环引用时候用到weak,今天我们就来研究下weak实现原理到底是什么。 weak入口 我们在这里打个断点,然后进入汇编调试。 这里就很明显看到了入口,objc_initWeak...

    基本上每一个面试都会问weak的实现原理,还有循环引用时候用到weak,今天我们就来研究下weak的实现原理到底是什么。

    weak入口

    我们在这里打个断点,然后进入汇编调试。

    这里就很明显看到了入口,objc_initWeak,接下来就进入objc的源码。官网链接,直接下载最新的

    在源码内顺序为objc_initWeak-->storeWeak-->weak_unregister_no_lock。下面为大致流程,内部还有些判断条件省略了。

    • 从SideTable散列表中找到弱引用表,
    • 从弱饮用表中获取weak_entry_t,根据有无weak_entry_t判断是否加入表或者新建weak_entry_t

    这就是weak引用的时候,接下来当对象释放的时候,为什么weak修饰的对象指针被置为nil。所以入口就是在dealloc函数中了。

    释放

    同样,我们在对象的dealloc搭上断点,汇编跟踪,最后进入了objc_destructInstance这个函数。

    进入源码,先判断是否有对象,再判断是c++析构函数,是否有关联对象再分对应的操作,之后就是跟weak有关的clearDeallocating

    /***********************************************************************
    * objc_destructInstance
    * Destroys an instance without freeing memory. 
    * Calls C++ destructors.
    * Calls ARC ivar cleanup.
    * Removes associative references.
    * Returns `obj`. Does nothing if `obj` is nil.
    **********************************************************************/
    void *objc_destructInstance(id obj) 
    {
        if (obj) {
            // Read all of the flags at once for performance.
            bool cxx = obj->hasCxxDtor();
            bool assoc = obj->hasAssociatedObjects();
    
            // This order is important.
            if (cxx) object_cxxDestruct(obj);
            if (assoc) _object_remove_assocations(obj, /*deallocating*/true);
            obj->clearDeallocating();
        }
    
        return obj;
    }
    inline void 
    objc_object::clearDeallocating()
    {
        if (slowpath(!isa.nonpointer)) {
            // Slow path for raw pointer isa.
            sidetable_clearDeallocating();
        }
        else if (slowpath(isa.weakly_referenced  ||  isa.has_sidetable_rc)) {
            // Slow path for non-pointer isa with weak refs and/or side table data.
            clearDeallocating_slow();
        }
    
        assert(!sidetable_present());
    }

    内部会调用sidetable_clearDeallocating,这里是根据对象找到对应的弱引用表,再进入weak_clear_no_lock

    void 
    objc_object::sidetable_clearDeallocating()
    {
        SideTable& table = SideTables()[this];
    
        // clear any weak table items
        // clear extra retain count and deallocating bit
        // (fixme warn or abort if extra retain count == 0 ?)
        table.lock();
        RefcountMap::iterator it = table.refcnts.find(this);
        if (it != table.refcnts.end()) {
            if (it->second & SIDE_TABLE_WEAKLY_REFERENCED) {
                weak_clear_no_lock(&table.weak_table, (id)this);
            }
            table.refcnts.erase(it);
        }
        table.unlock();
    }

    这里就是具体的释放了,先找到entry结构体数组,再遍历将referrer对象置为nil,最后移除弱引用表。

    void 
    weak_clear_no_lock(weak_table_t *weak_table, id referent_id) 
    {
        objc_object *referent = (objc_object *)referent_id;
    
        weak_entry_t *entry = weak_entry_for_referent(weak_table, referent);
        if (entry == nil) {
            /// XXX shouldn't happen, but does with mismatched CF/objc
            //printf("XXX no entry for clear deallocating %p\n", referent);
            return;
        }
    
        // zero out references
        weak_referrer_t *referrers;
        size_t count;
        
        if (entry->out_of_line()) {
            referrers = entry->referrers;
            count = TABLE_SIZE(entry);
        } 
        else {
            referrers = entry->inline_referrers;
            count = WEAK_INLINE_COUNT;
        }
        
        for (size_t i = 0; i < count; ++i) {
            objc_object **referrer = referrers[i];
            if (referrer) {
                if (*referrer == referent) {
                    *referrer = nil;
                }
                else if (*referrer) {
                    _objc_inform("__weak variable at %p holds %p instead of %p. "
                                 "This is probably incorrect use of "
                                 "objc_storeWeak() and objc_loadWeak(). "
                                 "Break on objc_weak_error to debug.\n", 
                                 referrer, (void*)*referrer, (void*)referent);
                    objc_weak_error();
                }
            }
        }
        
        weak_entry_remove(weak_table, entry);
    }

    总结

    weak的原理就是,在对象释放的时候,会根据对象地址,从弱引用表中找到entry数组,遍历置为nil

    展开全文
  • iOS:weak 底层实现原理

    千次阅读 2020-04-22 21:46:15
    weak 是弱引用,用 weak 来修饰、描述所引用对象的计数器并不会增加,而且 weak 会在引用对象被释放的时候自动置为 nil,这也就避免了野指针访问坏内存而引起奔溃的情况,另外 weak 也可以解决循环引用。 拓展:为...

    一、weak 基本用法

    weak 是弱引用,用 weak 来修饰、描述所引用对象的计数器并不会增加,而且 weak 会在引用对象被释放的时候自动置为 nil,这也就避免了野指针访问坏内存而引起奔溃的情况,另外 weak 也可以解决循环引用。

    拓展:为什么修饰代理使用 weak 而不是用 assign?

    assign 可用来修饰基本数据类型,也可修饰 OC 的对象,但如果用 assign 修饰对象类型指向的是一个强指针,当指向的这个指针释放之后,它仍指向这块内存,必须要手动给置为 nil,否则会产生野指针,如果还通过此指针操作那块内存,会导致 EXC_BAD_ACCESS 错误,调用了已经被释放的内存空间;而 weak 只能用来修饰 OC 对象,而且相比 assign 比较安全,如果指向的对象消失了,那么它会自动置为 nil,不会导致野指针。

    二、weak 原理概括

    weak 表其实是一个哈希表,key 是所指对象的指针,value 是 weak 指针的地址数组。(value 是数组的原因是:因为一个对象可能被多个弱引用指针指向)

    Runtime 维护了一张 weak 表,用来存储某个对象的所有的 weak 指针。

    weak 原理实现过程三步骤
    1. 初始化开始时,会调用 objc_initWeak 函数,初始化新的 weak 指针指向对象的地址。

    1. 然后 objc_initWeak 函数里面会调用 objc_storeWeak() 函数,objc_storeWeak() 函数的作用是用来更新指针的指向,创建弱引用表。

    1. 在最后会调用 clearDeallocating 函数。而clearDeallocating 函数首先根据对象的地址获取 weak 指针地址的数组,然后紧接着遍历这个数组,将其中的数组开始置为 nil,把这个 entry 从 weak 表中删除,最后一步清理对象的记录。

    拓展:详细步骤

    1. 初始化开始时,会调用 objc_initWeak 函数,初始化新的 weak 指针指向对象的地址。当我们初始化 weak 变量时,runtime 会调用 NSObject.mm 中的 objc_initWeak,而 objc_initWeak 函数里面的实现如下:
    id objc_initWeak(id *location, id newObj) {
    // 查看对象实例是否有效,无效对象直接导致指针释放
        if (!newObj) {
            *location = nil;
            return nil;
        }
        // 这里传递了三个 Bool 数值
        // 使用 template 进行常量参数传递是为了优化性能
        return storeWeakfalse/*old*/, true/*new*/, true/*crash*/>
        (location, (objc_object*)newObj);
    }
    

    通过上面代码可以看出,objc_initWeak()函数首先判断指针指向的类对象是否有效,无效,直接返回;否则通过 storeWeak() 被注册为一个指向 value 的 _weak 对象

    1. objc_initWeak 函数里面会调用 objc_storeWeak() 函数,objc_storeWeak() 函数的作用是用来更新指针的指向,创建弱引用表。

    2. 在最后会调用 clearDeallocating 函数。而 clearDeallocating 函数首先根据对象的地址获取 weak 指针地址的数组,然后紧接着遍历这个数组,将其中的数组开始置为 nil,把这个 entry 从 weak 表中删除,最后一步清理对象的记录。


    问:当 weak 指向的对象被释放时,如何让 weak 指针置为 nil 的呢?
    答:

    1. 调用 objc_release
    2. 因为对象的引用计数为0,所以执行 dealloc
    3. 在 dealloc 中,调用了 _objc_rootDealloc 函数
    4. 在 _objc_rootDealloc 中,调用了 object_dispose 函数
    5. 调用 objc_destructInstance
    6. 最后调用 objc_clear_deallocating,详细过程如下:
      a. 从 weak 表中获取废弃对象的地址为键值的记录
      b. 将包含在记录中的所有附有 weak 修饰符变量的地址,赋值为 nil
      c. 将 weak 表中该记录删除
      d. 从引用计数表中删除废弃对象的地址为键值的记录
    展开全文
  • iOS底层weak实现原理

    千次阅读 2019-01-24 10:29:14
    weak是弱引用,所引用对象的计数器不会加一,并在引用对象被释放的时候自动被设置为nil。那么weak的原理是什么呢?...weak 实现原理的概括 Runtime维护了一个weak表,用于存储指向某个对象的所有we...

    weak是弱引用,所引用对象的计数器不会加一,并在引用对象被释放的时候自动被设置为nil。那么weak的原理是什么呢?weak表其实是一个hash(哈希)表 (字典也是hash表),Key是所指对象的地址,Value是weak指针的地址集合。通常用于解决循环引用问题。下面就分析一下weak的工作原理。

    weak 实现原理的概括

    Runtime维护了一个weak表,用于存储指向某个对象的所有weak指针。weak表其实是一个hash(哈希)表,Key是所指对象的地址,Value是weak指针的地址(这个地址的值是所指对象指针的地址,就是地址的地址)集合(当weak指针的数量小于等于4时,是数组, 超过时,会变成hash表)。

    weak 的实现原理可以概括以下三步:

    1、初始化时:runtime会调用objc_initWeak函数,初始化一个新的weak指针指向对象的地址。
    2、添加引用时:objc_initWeak函数会调用 objc_storeWeak() 函数, objc_storeWeak() 的作用是更新指针指向,创建对应的弱引用表。
    3、释放时,调用clearDeallocating函数。clearDeallocating函数首先根据对象地址获取所有weak指针地址的数组,然后遍历这个数组把其中的数据设为nil,最后把这个entry从weak表中删除,清理对象的记录。

    下面将开始详细介绍每一步:

    1、初始化时:runtime会调用objc_initWeak函数,objc_initWeak函数会初始化一个新的weak指针指向对象的地址。

    示例代码:

    {
        NSObject *obj = [[NSObject alloc] init];
        id __weak obj1 = obj;
    }
    

    当我们初始化一个weak变量时,runtime会调用 NSObject.mm 中的objc_initWeak函数。这个函数在Clang中的声明如下:

    id objc_initWeak(id *object/*weak指针obj1*/, id value/*原始对象obj*/);
    

    而对于 objc_initWeak() 方法的实现

    // location指针obj1 , newObj原始对象obj
    id objc_initWeak(id *location, id newObj) {
    // 查看原始对象实例是否有效
    // 无效对象直接导致指针释放
        if (!newObj) {
            *location = nil;
            return nil;
        }
        // 这里传递了三个 bool 数值
        // 使用 template 进行常量参数传递是为了优化性能
        return storeWeak<false/*old*/, true/*new*/, true/*crash*/>
        (location, (objc_object*)newObj);
    }
    

    可以看出,这个函数仅仅是一个深层函数的调用入口,而一般的入口函数中,都会做一些简单的判断(例如 objc_msgSend 中的缓存判断),这里判断了其指针指向的类对象是否有效,无效直接释放,不再往深层调用函数。否则,object将被注册为一个指向value的__weak对象。而这事应该是objc_storeWeak函数干的。

    注意:objc_initWeak函数有一个前提条件:就是object必须是一个没有被注册为__weak对象的有效指针。而value则可以是null,或者指向一个有效的对象。

    2、添加引用时:objc_initWeak函数会调用 objc_storeWeak() 函数, objc_storeWeak() 的作用是更新指针指向,创建对应的弱引用表。

    objc_storeWeak的函数声明如下:

    objc_storeWeak函数把第二个参数--赋值对象(value)的内存地址作为键值key,
    将第一个参数 __weak修饰的属性变量(location)的内存地址(&location)作为value,注册到 weak 表中。
    
    id objc_storeWeak(id *location, id value);
    

    objc_storeWeak() 的具体实现如下:

    // HaveOld:  true - 变量有值
    //          false - 需要被及时清理,当前值可能为 nil
    // HaveNew:  true - 需要被分配的新值,当前值可能为 nil
    //          false - 不需要分配新值
    // CrashIfDeallocating: true - 说明 newObj 已经释放或者 newObj 不支持弱引用,该过程需要暂停
    //          false - 用 nil 替代存储
    template bool HaveOld, bool HaveNew, bool CrashIfDeallocating>
    static id storeWeak(id *location, objc_object *newObj) {
        // 该过程用来更新弱引用指针的指向
        // 初始化 previouslyInitializedClass 指针
        Class previouslyInitializedClass = nil;
        id oldObj;
        // 声明两个 SideTable
        // ① 新旧散列创建
        SideTable *oldTable;
        SideTable *newTable;
        // 获得新值和旧值的锁存位置(用地址作为唯一标示)
        // 通过地址来建立索引标志,防止桶重复
        // 下面指向的操作会改变旧值
    retry:
        if (HaveOld) {
            // 更改指针,获得以 oldObj 为索引所存储的值地址
            oldObj = *location;
            oldTable = &SideTables()[oldObj];
        } else {
            oldTable = nil;
        }
        if (HaveNew) {
            // 更改新值指针,获得以 newObj 为索引所存储的值地址
            newTable = &SideTables()[newObj];
        } else {
            newTable = nil;
        }
        // 加锁操作,防止多线程中竞争冲突
        SideTable::lockTwoHaveOld, HaveNew>(oldTable, newTable);
        // 避免线程冲突重处理
        // location 应该与 oldObj 保持一致,如果不同,说明当前的 location 已经处理过 oldObj 可是又被其他线程所修改
        if (HaveOld  &&  *location != oldObj) {
            SideTable::unlockTwoHaveOld, HaveNew>(oldTable, newTable);
            goto retry;
        }
        // 防止弱引用间死锁
        // 并且通过 +initialize 初始化构造器保证所有弱引用的 isa 非空指向
        if (HaveNew  &&  newObj) {
            // 获得新对象的 isa 指针
            Class cls = newObj->getIsa();
            // 判断 isa 非空且已经初始化
            if (cls != previouslyInitializedClass  &&
                !((objc_class *)cls)->isInitialized()) {
                // 解锁
                SideTable::unlockTwoHaveOld, HaveNew>(oldTable, newTable);
                // 对其 isa 指针进行初始化
                _class_initialize(_class_getNonMetaClass(cls, (id)newObj));
                // 如果该类已经完成执行 +initialize 方法是最理想情况
                // 如果该类 +initialize 在线程中
                // 例如 +initialize 正在调用 storeWeak 方法
                // 需要手动对其增加保护策略,并设置 previouslyInitializedClass 指针进行标记
                previouslyInitializedClass = cls;
                // 重新尝试
                goto retry;
            }
        }
        // ② 清除旧值
        if (HaveOld) {
            weak_unregister_no_lock(&oldTable->weak_table, oldObj, location);
        }
        // ③ 分配新值
        if (HaveNew) {
            newObj = (objc_object *)weak_register_no_lock(&newTable->weak_table,
                                                          (id)newObj, location,
                                                          CrashIfDeallocating);
            // 如果弱引用被释放 weak_register_no_lock 方法返回 nil
            // 在引用计数表中设置若引用标记位
            if (newObj  &&  !newObj->isTaggedPointer()) {
                // 弱引用位初始化操作
                // 引用计数那张散列表的weak引用对象的引用计数中标识为weak引用
                newObj->setWeaklyReferenced_nolock();
            }
            // 之前不要设置 location 对象,这里需要更改指针指向
            *location = (id)newObj;
        }
        else {
            // 没有新值,则无需更改
        }
        SideTable::unlockTwoHaveOld, HaveNew>(oldTable, newTable);
        return (id)newObj;
    }
    

    撇开源码中各种锁操作,来看看这段代码都做了些什么。

    1)、SideTable

    SideTable 这个结构体,我给他起名引用计数和弱引用依赖表,因为它主要用于管理对象的引用计数和 weak 表。在 NSObject.mm 中声明其数据结构:

    struct SideTable {
    // 保证原子操作的自旋锁
        spinlock_t slock;
        // 引用计数的 hash 表
        RefcountMap refcnts;
        // weak 引用全局 hash 表
        weak_table_t weak_table;
    }
    

    对于 slock 和 refcnts 两个成员不用多说,第一个是为了防止竞争选择的自旋锁,第二个是协助对象的 isa 指针的 extra_rc 共同引用计数的变量(对于对象结果,在今后的文中提到)。这里主要看 weak 全局 hash 表的结构与作用。

    2)、weak表

    weak表是一个弱引用表,实现为一个weak_table_t结构体,存储了某个对象相关的的所有的弱引用信息。其定义如下(具体定义在objc-weak.h中), 注意看系统的注释:

    /**
       全局的弱引用表, 保存object作为key, weak_entry_t作为value
     * The global weak references table. Stores object ids as keys,
     * and weak_entry_t structs as their values.
     */
    struct weak_table_t {
        // 保存了所有指向特地对象的 weak指针集合
        weak_entry_t *weak_entries;
        // weak_table_t中有多少个weak_entry_t
        size_t    num_entries;
        // weak_entry_t数组的count
        uintptr_t mask;
        // hash key 最大偏移值, 
        // 采用了开放定制法解决hash冲突,超过max_hash_displacement说明weak_table_t中不存在要找的weak_entry_t
        uintptr_t max_hash_displacement;
    };
    

    这是一个全局弱引用hash表。使用不定类型对象的地址作为 key ,用 weak_entry_t 类型结构体对象作为 value 。其中的 weak_entries 成员,从字面意思上看,即为弱引用表入口。其实现也是这样的。

    其中weak_entry_t是存储在弱引用表中的一个内部结构体,它负责维护和存储指向一个特定对象的所有弱引用集合。其定义如下:

    typedef objc_object ** weak_referrer_t;
    struct weak_entry_t {
        // 所有weak指针指向的特定对象
        DisguisedPtrobjc_object> referent;
        // 共用体,保存weak指针的集合, 
        // 小于等于4个时为数组(下面的结构体), 超过4个时为hash表(上面的结构体)
        union {
            struct {
                weak_referrer_t *referrers;
                uintptr_t        out_of_line : 1;
                uintptr_t        num_refs : PTR_MINUS_1;
                uintptr_t        mask;
                uintptr_t        max_hash_displacement;
            };
            struct {
                // out_of_line=0 is LSB of one of these (don't care which)
                weak_referrer_t  inline_referrers[WEAK_INLINE_COUNT];
            };
        }
    }
    

    在 weak_entry_t 的结构中,DisguisedPtr referent 是对泛型对象的指针做了一个封装,通过这个泛型类来解决内存泄漏的问题。而且weak_entry_t和weak_table_t内部都有一个hash表, 而且都是采用开放定值法解决的hash冲突, 从注释中写 out_of_line 成员为最低有效位,当其为1的时候, weak_referrer_t 成员将扩展为hash table。其中的 weak_referrer_t 是一个数组的别名。
    那么在有效位生效的时候,out_of_line 、 num_refs、 mask 、 max_hash_displacement 有什么作用?

    out_of_line:标志位。标志着weak_entry_t中是用数组保存还是hash表保存weak指针。
    num_refs:引用数值。这里记录weak_entry_t表中weak指针的数量,
    mask:weak_entry_t->referrers数组的count, 
    max_hash_displacement:hash key 最大偏移值, 采用了开放定制法解决hash冲突,超过max_hash_displacement说明weak_entry_t中不存在要找的weak_entry_t。
    其中 out_of_line 的值通常情况下是等于零的,所以弱引用表总是一个 objc_objective 指针数组,当 超过4时, 会变成hash表。

    总结一下 StripedMap[] : StripedMap 是一个模板类,在这个类中有一个 array 成员,用来存储 PaddedT 对象,并且其中对于 [] 符的重载定义中,会返回这个 PaddedT 的 value 成员,这个 value 就是我们传入的 T 泛型成员,也就是 SideTable 对象。在 array 的下标中,这里使用了 indexForPointer 方法通过位运算计算下标,实现了静态的 Hash Table。而在 weak_table 中,其成员 weak_entry 会将传入对象的地址加以封装起来,并且其中也有访问全局弱引用表的入口。

    旧对象解除注册操作 weak_unregister_no_lock

    该方法主要作用是将旧对象在 weak_table 中接触 weak 指针的对应绑定。根据函数名,称之为解除注册操作。从源码中,可以知道其功能就是从 weak_table 中解除weak 指针的绑定。而其中的遍历查询,就是针对于 weak_entry 中的多张弱引用散列表。

    新对象添加注册操作 weak_register_no_lock

    这一步与上一步相反,通过 weak_register_no_lock 函数把新的对象进行注册操作,完成与对应的弱引用表进行绑定操作。

    初始化弱引用对象流程一览

    弱引用的初始化,从上文的分析中可以看出,主要的操作部分就在弱引用表的取键、查询散列、创建弱引用表等操作,可以总结出如下的流程图:

    这个图中省略了很多情况的判断,但是当声明一个 __weak 会调用上图中的这些方法。当然, storeWeak 方法不仅仅用在 __weak 的声明中,在 class 内部的操作中也会常常通过该方法来对 weak 对象进行操作。

    3、释放时,调用clearDeallocating函数。clearDeallocating函数首先根据对象地址获取所有weak指针地址的数组,然后遍历这个数组把其中的数据设为nil,最后把这个entry从weak表中删除,最后清理对象的记录。

    当weak引用指向的对象被释放时,又是如何去处理weak指针的呢?当释放对象时,其基本流程如下:

    1、调用objc_release
    2、因为对象的引用计数为0,所以执行dealloc
    3、在dealloc中,调用了_objc_rootDealloc函数
    4、在_objc_rootDealloc中,调用了object_dispose函数
    5、调用objc_destructInstance
    6、最后调用objc_clear_deallocating

    重点看对象被释放时调用的objc_clear_deallocating函数。该函数实现如下:

    void  objc_clear_deallocating(id obj) 
    {
        assert(obj);
        assert(!UseGC);
        if (obj->isTaggedPointer()) return;
       obj->clearDeallocating();
    }
    

    也就是调用了clearDeallocating,继续追踪可以发现,它最终是使用了迭代器来取weak表的value,然后调用weak_clear_no_lock,然后查找对应的value,将该weak指针置空,weak_clear_no_lock函数的实现如下:

    /**
     * Called by dealloc; nils out all weak pointers that point to the
     * provided object so that they can no longer be used.
     *
     * @param weak_table
     * @param referent The object being deallocated.
     */
    void weak_clear_no_lock(weak_table_t *weak_table, id referent_id)
    {
        objc_object *referent = (objc_object *)referent_id;
        weak_entry_t *entry = weak_entry_for_referent(weak_table, referent);
        if (entry == nil) {
            /// XXX shouldn't happen, but does with mismatched CF/objc
            //printf("XXX no entry for clear deallocating %p\n", referent);
            return;
        }
        // zero out references
        weak_referrer_t *referrers;
        size_t count;
        
        if (entry->out_of_line) {
            referrers = entry->referrers;
            count = TABLE_SIZE(entry);
        }
        else {
            referrers = entry->inline_referrers;
            count = WEAK_INLINE_COUNT;
        }
        
        for (size_t i = 0; i < count; ++i) {
            objc_object **referrer = referrers[i];
            if (referrer) {
                if (*referrer == referent) {
                    *referrer = nil;
                }
                else if (*referrer) {
                    _objc_inform("__weak variable at %p holds %p instead of %p. "
                                 "This is probably incorrect use of "
                                 "objc_storeWeak() and objc_loadWeak(). "
                                 "Break on objc_weak_error to debug.\n",
                                 referrer, (void*)*referrer, (void*)referent);
                    objc_weak_error();
                }
            }
        }
        weak_entry_remove(weak_table, entry);
    }
    

    objc_clear_deallocating该函数的动作如下:

    1、从weak表中,以dealloc对象为key, 找到对应的weak_entry_t,
    2、将weak_entry_t中的所有附有 weak修饰符变量的地址,赋值为nil
    3、将weak表中该对象

    看了objc-weak.mm的源码就明白了:其实Weak表是一个hash(哈希)表,然后里面的key是指向对象的地址,Value是Weak指针的地址的集合。

    看了原理之后, 发现其实和 category中objc_setAssociatedObject的原理很类似 , 

    https://blog.csdn.net/u014600626/article/details/51435943

    展开全文
  • 在iOS中,使用weak关键字能够对内存对象进行弱引用,基于这个特性,使用weak...首先在分析weak关键字实现原理之前,先介绍一下相关的数据结构,这些数据结构其中一部分可能在其他地方有所提及,但本文只列出与we...
  • weak实现原理

    千次阅读 2018-05-21 14:15:42
    实现 weakweak 的作用weak 关键字的作用弱引用,所引用对象的计数器不会加一,并在引用对象被释放的时候自动被设置为 nil。如何实现 weak现在我们将 weak 的思路整理一下:整个系统中存在很多个对象,这些对象都可能...
  • iOS weak 实现原理

    2018-09-23 00:08:23
    如何实现 weak 现在我们将 weak 的思路整理一下: 整个系统中存在很多个对象,这些对象都可能会被弱引用,那么我们需要一个容器来容纳这些被弱引用的对象,比如数组,在此将这个容器的数据结构标识为 ...
  • 内存管理原理 两张表 1.引用计数表 (引用计数值, 是否为弱引用) 2.引用地址表 当对象将要被销毁时, 判断是否为弱引用, 有弱引用遍历弱引用地址列表设置为nil执行销毁操作   Runtime维护了一个weak表,用于...
  • weak 实现原理的概括

    2021-09-03 11:18:06
    weak实现原理可以概括一下三步: 1、初始化时:runtime会调用objc_initWeak函数,初始化一个新的weak指针指向对象的地址。 2、添加引用时:objc_initWeak函数会调用 objc_storeWeak() 函数, objc_storeWeak() ...
  • 前言 提起弱引用,大家都知道它的...那么,今天就带大家一起分析一下weak引用是怎么实现的,希望能够搞清楚每一个细节。 Store as weak 当我们要weak引用一个对象,我们可以这么做: int main(int argc, char...
  • 内存管理—weak实现原理 内存管理——autorelease原理分析 内存管理——定时器问题 iOS程序的内存布局 iOS引用计数的存储 我在 isa的深入体会 一文中介绍过,苹果从arm64架构开始,对isa进行了优化,...
  • iOS 中 weak实现原理

    2019-08-14 11:53:56
    weak底层千千万,吾竟装作看不见... weak基本用法 weak是弱引用,用weak描述修饰或者所引用对象的...weak原理概括 weak表其实是一个hash(哈希)表,Key是所指对象的地址,Value是weak指针的地址数组。weak的...
  • weak实现原理可以概括一下三步: 1、初始化时:runtime会调用objc_initWeak函数,初始化一个新的weak指针指向对象的地址。 2、添加引用时:objc_initWeak函数会调用 objc_storeWeak() 函数, objc_storeWeak() 的...
  • 2.weak实现原理 第一、通过weak编译解析,可以看出来weak通过runtime初始化的并维护的; 第二、weak和strong都是Object-C的修饰词,而strong是通过runtime维护的一个自动计数表结构。 综上:weak是有Runtime维护的...
  • 1.伪代码模拟weak用到的主要表 struct weak_referrer_t{ int weakPtr;//瞎写的不做参考 }; //hash表 struct weak_entry_t{ int index; //存储弱引用该对象的指针的指针的数组 weak_referrer_t inline_...
  • 浅谈iOS之weak底层实现原理

    千次阅读 2018-08-12 15:31:25
    前言 在iOS开发过程中,会经常使用到一个修饰词“weak”,使用场景大家都比较清晰,用于一些对象相互引用的时候,...weak底层原理 1.weak编译解析 首先需要看一下weak编译之后具体出现什么样的变化,通过Clang...
  • 问:当weak指向的对象被释放时,如何让weak指针置为nil的呢? 1、调用objc_release 2、因为对象的引用计数为0,所以执行dealloc 3、在dealloc中,调用了_objc_rootDealloc函数 4、在_objc_rootDealloc中,调用了...
  • Runtime维护了一个weak表,用于存储指向某个对象的所有...weak实现原理可以概括一下三步: 1、初始化时:runtime会调用objc_initWeak函数,初始化一个新的weak指针指向对象的地址。 2、添加引用时:objc_init...
  • weak 的内部实现原理

    2017-03-23 10:18:00
    问题 ...在 Friday QA 上,有一期专门介绍 weak实现原理。https://mikeash.com/pyblog/friday-qa-2010-07-16-zeroing-weak-references-in-objective-c.html 《Objective-C高级编程》一书中也介...
  • 是OC中weak功能实现的核心数据结构。 3.1、weak_table_t 先来看下weak_table_t的底层代码。 struct weak_table_t { weak_entry_t *weak_entries; size_t num_entries; uintptr_t mask; uintptr_t max_hash_...
  •  weak表是一个hash(哈希)表,Key是所指对象的地址,Value是weak指针的地址数组。weak是弱引用,所引用对象的计数器不会加一,并在引用对象被释放的时候自动被设置为nil。... weak 实现原理的概括  ...
  • weak是弱引用,用weak来修饰、描述所引用对象的计数器并不会加1,而且weak会在引用对象被释放的时候自动置为nil,这也就避免了野指针访问坏内存而引起奔溃的情况,另外weak也可以解决循环引用。 拓展:为什么修饰...
  • iOS weak 指针实现原理2

    2019-02-25 09:53:59
    SideTable 结构如下 struct SideTable { spinlock_t slock; ///线程同步锁 RefcountMap refcnts;... /// weak 散列表 所有 weak 指针存放在这个表里 }; weak_table_t 结构如下 struct weak_table_t { ...
  • 在 Friday QA 上,有一期专门介绍 weak实现原理。https://mikeash.com/pyblog/friday-qa-2010-07-16-zeroing-weak-references-in-objective-c.html 《Objective-C高级编程》一书中也介绍了相...
  • 很少有人知道weak表其实是一个hash(哈希)表,Key是所指...但现在单知道这些已经不足以应对面试了,好多公司会问weak原理weak原理是什么呢?下面就分析一下weak的工作原理(只是自己对这个问题好奇,学习过...
  • 主要介绍了 C++11智能指针之weak_ptr详解,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 原文 很少有人知道weak表其实是一个hash(哈希)表,Key是所指对象的地址,Value是weak指针的地址数组。更多人的人只是知道weak是弱引用,所引用对象的计数器...下面就分析一下weak的工作原理(只是自己对这个问题

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,554
精华内容 7,421
关键字:

weak实现原理