1
2
3
4

static StripedMap<SideTable>& SideTables() {
    static StripedMap<SideTable> sSideTables;
    return sSideTables;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

struct SideTable {
    // 1. 自旋锁：保证当前 SideTable 内所有操作的线程安全（分片锁）
    spinlock_t slock;         

    // 2. 强引用计数哈希表：存储对象的「补充引用计数」
    // 类型：DenseMap<void*, size_t>（key=对象地址，value=补充引用计数值）
    RefcountMap refcnts;       

    // 3. 弱引用表：存储对象的所有弱引用指针地址
    weak_table_t weak_table;   

    // 辅助：哈希表桶大小（优化性能）
    static size_t const TABLE_SIZE = 4096;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// SideTables 内置的哈希函数（简化版）
size_t indexForPointer(const void *p) {
    // 1. 取对象地址的 uintptr_t 类型值（指针转整数）
    uintptr_t addr = reinterpret_cast<uintptr_t>(p);
    // 2. 右移4位：避开低位噪声（内存对齐导致低位固定）
    // 3. 按位与 (stripeCount-1)：快速取模（stripeCount=8 → 0~7 索引）
    return (addr >> 4) & (stripeCount - 1);
}

// 获取对象对应的 SideTable
SideTable& table = SideTables()[obj];

1
2
3
4
5

① 哈希对象地址，找到对应的 SideTable；
② 加该 SideTable 的 slock 自旋锁；
③ 执行计数修改/弱引用注册；
④ 解锁；
⑤ 返回结果。

1
2
3
4
5
6
7
8

[obj retain] → 
① 哈希 obj 地址，找到 SideTables 中对应的 SideTable；
② 加该 SideTable 的 slock 锁；
③ 读取 obj->isa 的 `extra_rc`：
   - 若 `extra_rc < 最大值` → `extra_rc += 1`；
   - 若 `extra_rc 已满` → SideTables::refcnts[obj] += 1；
④ 解锁；
⑤ 返回新的 retainCount。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

[obj release] → 
① 哈希 obj 地址，找到 SideTables 中对应的 SideTable；
② 加该 SideTable 的 slock 锁；
③ 读取 obj->isa 的 `extra_rc`：
   - 若 `extra_rc > 0` → `extra_rc -= 1`；
   - 若 `extra_rc == 0` → SideTables::refcnts[obj] -= 1；
④ 检查总计数：
   - 若总计数 > 0 → 解锁，结束；
   - 若总计数 == 0 → 解锁，触发 obj->dealloc；
⑤ 结束。

1
2
3
4
5
6
7
8

storeWeak(&weakPtr, newObj) → 
① 哈希 oldObj 地址 → 找到 oldTable（SideTables[oldObj]）；
② 哈希 newObj 地址 → 找到 newTable（SideTables[newObj]）；
③ 加 oldTable/newTable 的 slock 锁（双锁，按地址排序防死锁）；
④ 移除 oldTable::weak_table 中 weakPtr 的地址（weak_unregister_no_lock）；
⑤ 注册 weakPtr 到 newTable::weak_table（weak_register_no_lock）；
⑥ 解锁；
⑦ 返回 newObj。

1
2
3
4
5
6
7
8

obj->dealloc → 
① 哈希 obj 地址，找到 SideTables 中对应的 SideTable；
② 加该 SideTable 的 slock 锁；
③ 遍历 SideTable::weak_table 中 obj 对应的所有 weak 指针地址；
④ 将所有 weak 指针置为 nil（避免野指针）；
⑤ 从 weak_table 中删除 obj 的条目；
⑥ 解锁；
⑦ 继续执行析构逻辑。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 模板类：StripedMap 是对任意类型 T 的分段哈希表包装（这里 T=SideTable）
template <typename T>
class StripedMap {
private:
    // 核心：分段数组（段数是 2 的幂，如 8/16，方便哈希取模）
    static const size_t stripeCount = 8; 
    T stripes[stripeCount]; // 每个元素是一个「段」（这里 T=SideTable，即每个段是一个 SideTable）

    // 哈希函数：将对象地址映射到具体的段索引
    size_t indexForPointer(const void *p) {
        // 取对象地址的哈希值，与 (stripeCount-1) 按位与，得到 0~stripeCount-1 的索引
        return ((uintptr_t)p >> 4) & (stripeCount - 1); 
    }

public:
    // 访问指定对象对应的段（SideTable）
    T& operator[] (const void *p) {
        return stripes[indexForPointer(p)];
    }
};

// 全局 SideTables：本质是 StripedMap<SideTable>
static StripedMap<SideTable>& SideTables() {
    static StripedMap<SideTable> sSideTables;
    return sSideTables;
}

1
2
3

① 取 obj 的地址（void *p = obj）；
② 调用 indexForPointer(p)，通过哈希计算得到段索引（如 3）；
③ 从 StripedMap 的 stripes 数组中取出索引 3 对应的 SideTable，即 obj 专属的 SideTable。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

线程 A 调用 [obj1 retain] → 
① 通过 SideTables()[obj1] 找到 obj1 对应的 SideTable（段 0）→ 
② 加该 SideTable 的 slock 锁 → 
③ 修改引用计数（isa 的 extra_rc 或 RefcountMap）→ 
④ 解锁。

线程 B 调用 [obj2 release] → 
① 通过 SideTables()[obj2] 找到 obj2 对应的 SideTable（段 1）→ 
② 加该 SideTable 的 slock 锁 → 
③ 修改引用计数 → 
④ 解锁。

→ 两个线程同时操作，锁互不干扰，无竞争。

1
2
3
4
5
6
7

线程 C 调用 storeWeak(&weakPtr, obj3) → 
① 通过 SideTables()[obj3] 找到 obj3 对应的 SideTable（段 2）→ 
② 加该 SideTable 的 slock 锁 → 
③ 注册 weak 指针到 weak_table → 
④ 解锁。

→ 与其他段的操作无竞争，并发安全。