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