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

最新推荐文章于 2024-07-26 20:25:06 发布

weixin_34150224

最新推荐文章于 2024-07-26 20:25:06 发布

阅读量68

点赞数

文章标签： runtime 数据结构与算法嵌入式

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

https://github.com/RetVal/objc-runtime

对象与 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背后其实就是对引用计数的操作，下次再深入分析。

weixin_34150224

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
读 Runtime 源码：对象与引用计数

以前只是看了很多博客，这次打算看一下源码，并记录下来。想到哪里就读到哪里，写到哪里。读的代码版本是：objc runtime 680,可以从这里下载https://github.com/RetVal/objc-runtime 对象与 isa 指针开始阅读源码，首先打开 objc-private.h文件，查看对于 Objectiv-C 的对象的定...
复制链接

扫一扫