struct SideTable {
  // 自旋鎖，用來保證線程安全
  spinlock_t slock;
  // 引用計(jì)數(shù)表
  RefcountMap refcnts;
  // weak 表
  weak_table_t weak_table;

  ...
};

struct weak_table_t {
  // 保存了所有指向指定對象的 weak 指針
  weak_entry_t *weak_entries;
  // 存儲空間，即 entries 的數(shù)目
  size_t  num_entries;
  // 參與判斷引用計(jì)數(shù)輔助量
  uintptr_t mask;
  // hash key 最大偏移量
  uintptr_t max_hash_displacement;
};

// 存儲在弱引用表中的一個內(nèi)部結(jié)構(gòu)體
#define WEAK_INLINE_COUNT 4
struct weak_entry_t {
  DisguisedPtr<objc_object> referent;         // 封裝 objc_object 指針，即 weak 修飾的變量指向的對象
  union {
    struct {
      weak_referrer_t *referrers;
      uintptr_t    out_of_line : 1;      // LSB 最低有效元 當(dāng)標(biāo)志位為0時，增加引用表指針緯度，
                            // 當(dāng)其為0的時候， weak_referrer_t 成員將擴(kuò)展為靜態(tài)數(shù)組型的 hash table
      uintptr_t    num_refs : PTR_MINUS_1;  // 引用數(shù)值，這里記錄弱引用表中引用有效數(shù)字，即里面元素的數(shù)量
      uintptr_t    mask;
      uintptr_t    max_hash_displacement;   // hash 元素上限閥值
    };
    struct {
      // out_of_line=0 is LSB of one of these (don't care which)
      weak_referrer_t inline_referrers[WEAK_INLINE_COUNT];   
    };
  };
};

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

id objc_initWeak(id *location, id newObj)
{
  // 查看對象實(shí)例是否有效
  // 無效對象直接導(dǎo)致指針釋放
  if (!newObj) {
    *location = nil;
    return nil;
  }
  // 這里傳遞了三個 bool 數(shù)值
  // 使用 template 進(jìn)行常量參數(shù)傳遞是為了優(yōu)化性能
  return storeWeak<false/*old*/, true/*new*/, true/*crash*/>
    (location, (objc_object*)newObj);
}

void objc_destroyWeak(id *location)
{
  (void)storeWeak<true/*old*/, false/*new*/, false/*crash*/>
    (location, nil);
}

// 更新一個弱引用變量
// 如果 HaveOld 是 true, 變量是個有效值，需要被及時清理。變量可以為 nil。
// 如果 HaveNew 是 true, 需要一個新的 value 來替換變量。變量可以為 nil
// 如果crashifdeallocation 是 ture ，那么如果 newObj 是 deallocating，或者 newObj 的類不支持弱引用，則該進(jìn)程就會停止。
// 如果crashifdeallocation 是 false，那么 nil 會被存儲。

template <bool HaveOld, bool HaveNew, bool CrashIfDeallocating>
static id storeWeak(id *location, objc_object *newObj)
{
  assert(HaveOld || HaveNew);
  if (!HaveNew) assert(newObj == nil);

  Class previouslyInitializedClass = nil;
  id oldObj;
  
  // 創(chuàng)建新舊散列表
  SideTable *oldTable;
  SideTable *newTable;

  // Acquire locks for old and new values.
  // 獲得新值和舊值的鎖存位置 (用地址作為唯一標(biāo)示)
  // Order by lock address to prevent lock ordering problems.
  // 通過地址來建立索引標(biāo)志，防止桶重復(fù)
  // Retry if the old value changes underneath us.
  // 下面指向的操作會改變舊值
 retry:
  if (HaveOld) {
  // 如果 HaveOld 為 true ，更改指針，獲得以 oldObj 為索引所存儲的值地址
    oldObj = *location;
    oldTable = &SideTables()[oldObj];
  } else {
    oldTable = nil;
  }
  if (HaveNew) {
  // 獲得以 newObj 為索引所存儲的值對象
    newTable = &SideTables()[newObj];
  } else {
    newTable = nil;
  }
  
// 對兩個 table 進(jìn)行加鎖操作，防止多線程中競爭沖突
  SideTable::lockTwo<HaveOld, HaveNew>(oldTable, newTable);

// location 應(yīng)該與 oldObj 保持一致，如果不同，說明當(dāng)前的 location 已經(jīng)處理過 oldObj 可是又被其他線程所修改, 保證線程安全，這個判斷用來避免線程沖突重處理問題
  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.
  // 防止弱引用之間發(fā)生死鎖，并且通過 +initialize 初始化構(gòu)造器保證所有弱引用的 isa 非空指向
  if (HaveNew && newObj) {
    // 獲得新對象的 isa 指針
    Class cls = newObj->getIsa();
    // 判斷 isa 非空且已經(jīng)初始化
    if (cls != previouslyInitializedClass && 
      !((objc_class *)cls)->isInitialized()) 
    {
      // 對兩個表解鎖
      SideTable::unlockTwo<HaveOld, HaveNew>(oldTable, newTable);
      _class_initialize(_class_getNonMetaClass(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.
      // 如果該類已經(jīng)完成執(zhí)行 +initialize 方法是最好的，如果該類 + initialize 在線程中，例如 +initialize 正在調(diào)用storeWeak 方法，那么則需要手動對其增加保護(hù)策略，并設(shè)置 previouslyInitializedClass 指針進(jìn)行標(biāo)記然后重新嘗試
      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
    // 如果弱引用被釋放則該方法返回 nil
    // Set is-weakly-referenced bit in refcount table.
    // 在引用計(jì)數(shù)表中設(shè)置弱引用標(biāo)記位
    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;
}

void weak_unregister_no_lock(weak_table_t *weak_table, id referent_id, 
            id *referrer_id)
{
  objc_object *referent = (objc_object *)referent_id;
  objc_object **referrer = (objc_object **)referrer_id;

  weak_entry_t *entry;

  if (!referent) return;

  if ((entry = weak_entry_for_referent(weak_table, referent))) {
    remove_referrer(entry, 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);
    }
  }

  // Do not set *referrer = nil. objc_storeWeak() requires that the 
  // value not change.
}

static weak_entry_t *weak_entry_for_referent(weak_table_t *weak_table, objc_object *referent)
{
  assert(referent);

  weak_entry_t *weak_entries = weak_table->weak_entries;

  if (!weak_entries) return nil;

  size_t index = hash_pointer(referent) & weak_table->mask;
  size_t hash_displacement = 0;
  while (weak_table->weak_entries[index].referent != referent) {
    index = (index+1) & weak_table->mask;
    hash_displacement++;
    if (hash_displacement > weak_table->max_hash_displacement) {
      return nil;
    }
  }

  return &weak_table->weak_entries[index];
}

static void remove_referrer(weak_entry_t *entry, objc_object **old_referrer)
{
  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;
  }

  size_t index = w_hash_pointer(old_referrer) & (entry->mask);
  size_t hash_displacement = 0;
  while (entry->referrers[index] != old_referrer) {
    index = (index+1) & entry->mask;
    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;
    }
  }
  entry->referrers[index] = nil;
  entry->num_refs--;
}

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;
  objc_object **referrer = (objc_object **)referrer_id;

  if (!referent || referent->isTaggedPointer()) return referent_id;

  // ensure that the referenced object is viable
  bool deallocating;
  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))) {
    append_referrer(entry, referrer);
  } 
  else {
    weak_entry_t new_entry;
    new_entry.referent = referent;
    new_entry.out_of_line = 0;
    new_entry.inline_referrers[0] = referrer;
    for (size_t i = 1; i < WEAK_INLINE_COUNT; i++) {
      new_entry.inline_referrers[i] = nil;
    }

    weak_grow_maybe(weak_table);
    weak_entry_insert(weak_table, &new_entry);
  }

  // Do not set *referrer. objc_storeWeak() requires that the 
  // value not change.

  return referent_id;
}

static void append_referrer(weak_entry_t *entry, objc_object **new_referrer)
{
  if (! entry->out_of_line) {
    // Try to insert inline.
    for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
      if (entry->inline_referrers[i] == nil) {
        entry->inline_referrers[i] = new_referrer;
        return;
      }
    }

    // Couldn't insert inline. Allocate out of line.
    weak_referrer_t *new_referrers = (weak_referrer_t *)
      calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t));
    // This constructed table is invalid, but grow_refs_and_insert
    // will fix it and rehash it.
    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 = 1;
    entry->mask = WEAK_INLINE_COUNT-1;
    entry->max_hash_displacement = 0;
  }

  assert(entry->out_of_line);

  if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) {
    return grow_refs_and_insert(entry, new_referrer);
  }
  size_t index = w_hash_pointer(new_referrer) & (entry->mask);
  size_t hash_displacement = 0;
  while (entry->referrers[index] != NULL) {
    index = (index+1) & entry->mask;
    hash_displacement++;
  }
  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++;
}

void objc_clear_deallocating(id obj) 
{
  assert(obj);
  assert(!UseGC);

  if (obj->isTaggedPointer()) return;
  obj->clearDeallocating();
}

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

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