读 Runtime源码：对象与引用计数

以前只是看了很多博客，这次打算看一下源码，并记录下来。想到哪里就读到哪里，写到哪里。读的代码版本是：objc runtime 680,可以从这里下载

对象与 isa 指针

开始阅读源码，首先打开 objc-private.h文件，查看对于 Objectiv-C 的对象的定义

struct objc_object {
private:
    isa_t isa;
public:
    void initIsa(Class cls /*indexed=false*/);
private:
    void initIsa(Class newCls, bool indexed, bool hasCxxDtor);
｝

每个对象都包含一个 isa指针，指向 isa_t 结构体，对isa_t结构体的内部一探究竟

union isa_t 
{
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    Class cls;
    uintptr_t bits;
    
#if SUPPORT_NONPOINTER_ISA

# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
#   define ISA_MAGIC_MASK  0x000003f000000001ULL
#   define ISA_MAGIC_VALUE 0x000001a000000001ULL
    struct {
        uintptr_t indexed           : 1;
        uintptr_t has_assoc         : 1;
        uintptr_t has_cxx_dtor      : 1;
        uintptr_t shiftcls          : 33; // MACH_VM_MAX_ADDRESS 0x1000000000
        uintptr_t magic             : 6;
        uintptr_t weakly_referenced : 1;
        uintptr_t deallocating      : 1;
        uintptr_t has_sidetable_rc  : 1;
        uintptr_t extra_rc          : 19;
#       define RC_ONE   (1ULL<<45)
#       define RC_HALF  (1ULL<<18)
    };

# elif __x86_64__
#   define ISA_MASK        0x00007ffffffffff8ULL
#   define ISA_MAGIC_MASK  0x001f800000000001ULL
#   define ISA_MAGIC_VALUE 0x001d800000000001ULL
    struct {
        uintptr_t indexed           : 1;
        uintptr_t has_assoc         : 1;
        uintptr_t has_cxx_dtor      : 1;
        uintptr_t shiftcls          : 44; // MACH_VM_MAX_ADDRESS 0x7fffffe00000
        uintptr_t magic             : 6;
        uintptr_t weakly_referenced : 1;
        uintptr_t deallocating      : 1;
        uintptr_t has_sidetable_rc  : 1;
        uintptr_t extra_rc          : 8;
#       define RC_ONE   (1ULL<<56)
#       define RC_HALF  (1ULL<<7)
    };
｝

可以看到源码里面有一个#if SUPPORT_NONPOINTER_ISA来判断是否支持isa指针优化，那么来看一下SUPPORT_NONPOINTER_ISA的具体实现，打开objc-config.h的82行可以看到

// Define SUPPORT_NONPOINTER_ISA=1 to enable extra data in the isa field.
#if !__LP64__  ||  TARGET_OS_WIN32  ||  TARGET_IPHONE_SIMULATOR
#   define SUPPORT_NONPOINTER_ISA 0
#else
#   define SUPPORT_NONPOINTER_ISA 1
#endif

我们的电脑是 x86_64的处理器，那么TARGET_IPHONE_SIMULATOR也是x86_64的处理器，那么可以得知，目前只有arm64设备支持isa优化，我们所使用的手机正是支持此优化

目前我们使用的设备都是 64位的，也就是说isa 指针是一个64 bit的指针，那么如果全用来存放内存地址就显得有些浪费，于是苹果有引入一种技术叫 Tagged Pointer。

64位超大地址的出现，如果仅用来存放内存地址比较浪费，我们可以在指针地址中保存或附加更多的信息，这就是Tagged Pointer

那么tagged pointer在 isa中有什么运用呢？可以看出来 isa_t结构体中 64位并不是全部用来存放内存地址，到底怎么放，来看一下 isa指针的初始化过程。

inline void 
objc_object::initIsa(Class cls)
{
    initIsa(cls, false, false);
}

inline void 
objc_object::initIsa(Class cls, bool indexed, bool hasCxxDtor) 
{ 
    assert(!isTaggedPointer()); 
    
    if (!indexed) {
        isa.cls = cls;
    } else {
        assert(!DisableIndexedIsa);
        isa.bits = ISA_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.indexed is part of ISA_MAGIC_VALUE
        isa.has_cxx_dtor = hasCxxDtor;
        isa.shiftcls = (uintptr_t)cls >> 3;
    }
}

会根据传入的indexed来判断进行那种初始化方式，如果是indexed为0，则仍然按照以前的方式进行初始化，也就是访问isa指针的时候，直接返回指向class的指针。也不会利用到刚才所讲到Tagged Pointer

union isa_t 
{
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    Class cls;
    uintptr_t bits;
｝

当indexed为1的时候，就会启动优化isa指针优化，也就是说isa不再单单是类的指针，还包含更多的信息，比如：引用计数、是否被weak引用等情况。

# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
#   define ISA_MAGIC_MASK  0x000003f000000001ULL
#   define ISA_MAGIC_VALUE 0x000001a000000001ULL
    struct {
        uintptr_t indexed           : 1;
        uintptr_t has_assoc         : 1;
        uintptr_t has_cxx_dtor      : 1;
        uintptr_t shiftcls          : 33; // MACH_VM_MAX_ADDRESS 0x1000000000
        uintptr_t magic             : 6;
        uintptr_t weakly_referenced : 1;
        uintptr_t deallocating      : 1;
        uintptr_t has_sidetable_rc  : 1;
        uintptr_t extra_rc          : 19;
#       define RC_ONE   (1ULL<<45)
#       define RC_HALF  (1ULL<<18)
    };

既然已经揭开了结构体的面纱，就接着分析下每个变量所对应的含义吧

has_assoc
- 表示该对象是否包含关联对象
has_cxx_dtor
- 表示该对象是否有 C++ 或者 Objc 的析构器
shiftcls
- 类的指针
magic
- 判断对象是否初始化完成
weakly_referenced
- 对象是否被指向一个弱变量
deallocating
- 对象正在释放内存
has_sidetable_rc
- 判断该对象的引用计数是否过大，如果过大则需要其他散列表来进行存储
extra_rc
存放该对象的引用计数值减一后的结果

引用计数

刚才说到 isa里面存储引用计数的问题，如果不支持isa优化，或者说，isa里面存储不够用，这个时候就需要把引用计数交给SideTable去管理

struct SideTable {
    spinlock_t slock;    //锁
    RefcountMap refcnts; //保存引用计数的的散列表 
    weak_table_t weak_table; //保存weak引用的散列表
｝

对于引用计数计数的散列表定义如下

// RefcountMap disguises its pointers because we 
// don't want the table to act as a root for `leaks`.
typedef objc::DenseMap,size_t,true> RefcountMap;

DenseMap是用来存储引用计数，Key可以理解为对象的内存地址，value对应的是引用计数的值减 1

weak 表示弱引用，这个引用不会增加对象的引用计数，并且在对象释放之后，weak指针被置为nil，好吧！这个都知道，但是内部具体是怎么实现的呢？

weak

打开objc-weak.h文件可以看到以下代码


struct weak_table_t {
    weak_entry_t *weak_entries;
    size_t    num_entries;
    uintptr_t mask;
    uintptr_t max_hash_displacement;
};

weak_table_t结构体存储了与对象弱引用相关的信息，weak_entry_t是负责来存储对象弱引用关系的散列表

/**
 * The internal structure stored in the weak references table. 
 * It maintains and stores
 * a hash set of weak references pointing to an object.
 * If out_of_line==0, the set is instead a small inline array.
 */
#define WEAK_INLINE_COUNT 4
struct weak_entry_t {
    DisguisedPtr referent;
    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];
        };
    };
};

其中referent是被引用对象，union存储了指向该对象的weak指针。由注释可以知道，如果out_of_line等于0的时候，hash表被一个数组所代替。

然后看一下，weak变量到底是怎么初始化的，这个hash表又是怎么利用起来的。

id __weak obj1 = obj;

当我们初始化一个weak变量的时候，runtime会调用objc_initWeak函数

objc_initWeak(id *location, id newObj)
{
    if (!newObj) {
        *location = nil;
        return nil;
    }

    return storeWeak
        (location, (objc_object*)newObj);
}

location代表的是_weak修饰的指针，而newObj则是一个对象。会首先进行一个判断，如果newObj是一个空指针或者所指向的对象已经释放了，那么就会直接返回nil，也就是_weak指针变为nil

如果newObj是一个有效的对象，就会调用storeWeak方法，对源代码整理了之后，如下


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) {
        oldObj = *location;
        oldTable = &SideTables()[oldObj];
    } else {
        oldTable = nil;
    }
    if (HaveNew) {
        newTable = &SideTables()[newObj];
    } else {
        newTable = nil;
    }
    SideTable::lockTwo(oldTable, newTable);
    
    if (HaveOld  &&  *location != oldObj) {
        SideTable::unlockTwo(oldTable, newTable);
        goto retry;
    }

    if (HaveNew  &&  newObj) {
        Class cls = newObj->getIsa();
        if (cls != previouslyInitializedClass  &&
            !((objc_class *)cls)->isInitialized())
        {
            SideTable::unlockTwo(oldTable, newTable);
            _class_initialize(_class_getNonMetaClass(cls, (id)newObj));

            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);
        if (newObj  &&  !newObj->isTaggedPointer()) {
            newObj->setWeaklyReferenced_nolock();
        }
        *location = (id)newObj;
    }
    else {
    }
    SideTable::unlockTwo(oldTable, newTable);
    
    return (id)newObj;
}

有点长呀！首先判断是否存在weak指针以前是否指向旧对象，如果存在旧对象，就根据weak指针找到旧对象，并获取旧对象的sideTable对象

    if (HaveOld) {
        oldObj = *location;
        oldTable = &SideTables()[oldObj];
    } else {
        oldTable = nil;
    }

获取新对象的sideTable对象

    if (HaveNew) {
        newTable = &SideTables()[newObj];
    } else {
        newTable = nil;
    }

然后就是在老对象的weak表中移除此weak变量的信息，在新对象的weak表中与当前weak变量建立关系

    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);
        if (newObj  &&  !newObj->isTaggedPointer()) {
            newObj->setWeaklyReferenced_nolock();
        }
        *location = (id)newObj;
    }

最后让_weak指针指向新对象，并返回新对象

*location = (id)newObj;
return (id)newObj;

Strong

谈到weak总会带上strong，那也说一点吧！可以从NSObject.mm中看到objc_storeStrong的代码，也就是对当前指针所指向新旧对象的计数表进行操作

objc_storeStrong(id *location, id obj)
{
    id prev = *location;
    if (obj == prev) {
        return;
    }
    objc_retain(obj);
    *location = obj;
    objc_release(prev);
}

也就是根据当前strong指针指向的位置找到旧对象，然后对旧对象执行release操作，对新对象执行retain操作，并把strong指针从新指向新对象。retain与release背后其实就是对引用计数的操作，下次再深入分析。

如果有理解错误，望留言告知

读 Runtime源码：对象与引用计数

对象与 isa 指针

引用计数

weak

Strong

你可能感兴趣的:(读 Runtime源码：对象与引用计数)