以前只是看了很多博客，这次打算看一下源码，并记录下来。想到哪里就读到哪里，写到哪里。读的代码版本是：
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<DisguisedPtr<objc_object>,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<objc_object> 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<false/*old*/, true/*new*/, true/*crash*/>
(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<HaveOld, HaveNew>(oldTable, newTable);
if (HaveOld && *location != oldObj) {
SideTable::unlockTwo<HaveOld, HaveNew>(oldTable, newTable);
goto retry;
}
if (HaveNew && newObj) {
Class cls = newObj->getIsa();
if (cls != previouslyInitializedClass &&
!((objc_class *)cls)->isInitialized())
{
SideTable::unlockTwo<HaveOld, HaveNew>(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<HaveOld, HaveNew>(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背后其实就是对引用计数的操作，下次再深入分析。
如果有理解错误，望留言告知
