OC归纳总结 — （3）OC对象的内存管理

OC的内存管理方式是使用对象的引用计数为维护, 简单来说就是谁创建, 谁释放, 谁引用谁管理的机制, , 其中关键函数如下:

retain  - 引用计数 + 1
release - 引用计数 - 1
retainCount - 引用计数
​
alloc   - 分配内存, 构造isa
dealloc - 释放空间
复制代码

• 以 alloc、new、copy、mutableCopy 创建的对象, 引用计数+1
• 调用对象的 retain 方法之后它的引用计数+1
• 调用对象的 release 方法之后它的引用计数-1
• 如果一个对象的引用计数为0, 系统会自动调用dealloc方法释放该对象

在ARC中, 编译器会在编译时, 帮我们插入retain, release, autorelase 等方法, 不用我们手动调用. 但是MRC中需要开发者手动管理.

MRC中, dealloc 方法需要在最后手动调用super.dealloc方法!

0. 父类可能被其他对象引用
1. 本类最终的释放时在父类中完成

OC对象引用计数存储的位置与弱引用表

OC中对象的引用计数在arm64以后, 存储在对象的isa的最后几个关键的bit:

uintptr_t has_sidetable_rc  : 1; 
uintptr_t extra_rc          : 19
复制代码

其中extra_rc用来存储该对象的引用计数信息, 如果无法存储下, 需要借助全局的sideTables来存储一半的引用计数值.关于使用extra_rc存储引用计数信息略过, 下面直接看SideTable相关内容

在isa中有一个has_sidetable_rc标记该对象是否拥有SideTable来帮助管理引用计数.

而在iOS系统中, 操作系统会在APP启动时候, 分配一个全局的静态的SideTables的Map!!!! 它是一个HashTable.

在iOS系统中内部存储着8张SideTable表!!!使用一个与OC对象地址相关的Hash函数选择对应的SideTable:

struct SideTable {
    spinlock_t slock;//自旋锁
    RefcountMap refcnts;//引用计数表 -- RefcountMap其实是个C++的Map, 也是用OC对象地址相关的Hash函数计算的key
    weak_table_t weak_table;//弱引用表 --  weak_table_t   weak_table
}
​
struct weak_table_t {
    weak_entry_t *weak_entries; // 是一个 weak_entry_t 的 HashTable
    size_t    num_entries;      // 数组中的元素个数
    ...
};
​
struct weak_entry_t {
    DisguisedPtr<objc_object> referent; //被弱引用的对象, 当这个对象被释放的时候，referrers里的所有指针都会被设置成nil。
  
    // 引用该对象的对象列表
    // 联合体: 引用个数小于4用固定数组, >4, 用动态数组 
    union{
        weak_referrer_t *referrers;  // 弱引用该对象的对象指针地址的hash数组
        weak_referrer_t  inline_referrers[WEAK_INLINE_COUNT];
        ...
    }
}
复制代码

结论:

0. SideTables是一个Map, 维护多个SideTable
1. OC对象关联的SideTable维护着对象的引用计数表和一个弱引用表
2. 引用计数表实际也是一个Map, 需要用对象的地址再查一次, 才能找到真正的引用计数相关的信息.
3. weak_table是全局的弱引用表, referent 是引用对象的指针, referrer是weak指针的地址, 因此当对象释放时, 会将全部的referrer被设置成nil!!

Apple 设计 SideTables 这样一个HashMap来持有多个SideTable, 为了减少加锁带来的性能损失, 可以简单理解成一个数组SideTables[8]

OC的dealloc方法

在有了以上知识以后, 再看oc的 dealloc方法!!!

前面说到当OC对象被调用release方法时, 发现引用计数为0, 会调用dealloc方法, 该方法的源码如下:

- (void)dealloc {
    _objc_rootDealloc(self);
}
​
void _objc_rootDealloc(id obj){
    assert(obj);
    obj->rootDealloc();
}
​
inline void objc_object::rootDealloc(){
    if (isTaggedPointer()) return;  // fixme necessary?
    /*
    通过isa判断, 没有以下情况, 直接free!!!
    1. 是否拥有弱引用指针指向本对象
    2. 是否有关联对象
    3. 是否有cxx析构函数
    4. 是否有sidetable
    */ 
    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);
    }
}
​
id object_dispose(id obj) {
    if (!obj) return nil;
    objc_destructInstance(obj);    
    free(obj);
    return 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;
}
​
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());
}
​
void objc_object::clearDeallocating_slow() {
    assert(isa.nonpointer  &&  (isa.weakly_referenced || isa.has_sidetable_rc));
​
    /*
    处理SideTable, 获取对象关联的SideTable
    1. 清理 weak_table 表, 主要是设置成nil, 然后清理weak_table表
    2. 引用计数表处理
    */
    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();
}
​
void  weak_clear_no_lock(weak_table_t *weak_table, id referent_id)  {
    // 调用 dealloc 的对象
    objc_object *referent = (objc_object *)referent_id;
​
    // 获取hashTable最终的 weak_entry_t * 指针!
    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;
    }
    
    // 遍历一个 __weak 指针判断, 循环将 referrer 指针设置成nil!!!
    for (size_t i = 0; i < count; ++i) {
        objc_object **referrer = referrers[i];
        if (referrer) {
            if (*referrer == referent) { // 判断 __weak 指针指向的是否是引用对象!!!
                *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();
            }
        }
    }
    // 将这个 entry 从 weak_table中移除
    weak_entry_remove(weak_table, entry);
}
复制代码

源码中的逻辑非常清楚, 大概流程如下:

1. release以后, 对象如果需要释放, 就会调用dealloc
2. 判断对象的isa, 按照顺序释放关联对象, cxx析构函数
3. 判断弱引用标志位, 处理weak_table中的弱引用指针, 然后将对象关联的weak_entry从弱引用表中移除
4. 判断是否有使用引用计数表, 处理附加引用计数表!!