一、isa 简介
- alloc初始化时不仅创建了对象并且分配内存，同时初始化 isa 指针属性。Objective-C 对象在底层本质上是结构体，所有的对象里面都会包含有一个 isa ，isa 的定义是一个联合体 isa_t，isa_t 包含了当前对象指向类的信息。
- isa 是一个联合体，而这其实是从内存管理层面来设计的，因为联合体是所有成员共享一个内存，联合体内存的大小取决于内部成员内存大小最大的那个元素，对于 isa 指针来说，就不用额外声明很多的属性，直接在内部的 ISA_BITFIELD 保存信息。同时由于联合体属性间是互斥的，所以 cls 和 bits 在 isa 初始化流程时是在两个分支中被赋值的。
union isa_t {
isa_t() { }
isa_t(uintptr_t value) : bits(value) { }
Class cls;
uintptr_t bits;
#if defined(ISA_BITFIELD)
struct {
ISA_BITFIELD; // defined in isa.h
};
#endif
};
# define ISA_MASK 0x00007ffffffffff8ULL
# define ISA_MAGIC_MASK 0x001f800000000001ULL
# define ISA_MAGIC_VALUE 0x001d800000000001ULL
# define ISA_BITFIELD \
uintptr_t nonpointer : 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)
- isa_t 是一个联合体，联合体的特性就是内部所有的成员共用一块内存地址空间，也就是说isa_t、cls、bits会共用同一块内存地址空间，这块内存地址空间大小取决于最大长度内部成员的大小即64位8字节，由此可以知道isa 的所占的内存空间大小为8字节。isa_t联合体如下：
struct {
uintptr_t indexed : 1;
uintptr_t has_assoc : 1;
uintptr_t has_cxx_dtor : 1;
uintptr_t shiftcls : 44;
uintptr_t magic : 6;
uintptr_t weakly_referenced : 1;
uintptr_t deallocating : 1;
uintptr_t has_sidetable_rc : 1;
uintptr_t extra_rc : 8;
};
二、isa 结构
isa 作为一个联合体，有一个结构体属性为 ISA_BITFIELD，其大小为 8 个字节，也就是 64 位。基于 arm64 架构如下：
# define ISA_BITFIELD \
uintptr_t nonpointer : 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
- nonpointer: 表示是否对 isa 指针开启指针优化：
0: 纯 isa 指针；
1: 不止是类对象地址, isa 中包含了类信息、对象的引用计数等。 - has_assoc: 关联对象标志位，0 没有，1 存在。
- has_cxx_dtor: 该对象是否有 C++ 或者 Objc 的析构器，如果有析构函数，则需要做析构逻辑，如果没有，则可以更快的释放对象。
- shiftcls: 存储类指针的值，开启指针优化的情况下，在 arm64 架构中有 33 位用来存储类指针。
- magic: 用于调试器判断当前对象是真的对象还是没有初始化的空间。
- weakly_referenced: 标志对象是否被指向或者曾经指向一个 ARC 的弱变量，没有弱引用的对象可以更快释放。
- deallocating: 标志对象是否正在释放内存。
- has_sidetable_rc: 当对象引用技术大于 10 时，则需要借用该变量存储进位。
- extra_rc: 当表示该对象的引用计数值，实际上是引用计数值减 1。 例如，如果对象的引用计数为 10，那么 extra_rc 为 9；如果引用计数大于 10， 则需要使用到has_sidetable_rc。
三、isa 初始化
① isa 源码实现
- 在objc的源码中有isa的初始化方法：
inline void
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor) {
assert(!cls->instancesRequireRawIsa());
assert(hasCxxDtor == cls->hasCxxDtor());
initIsa(cls, true, hasCxxDtor);
}
inline void
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) {
assert(!isTaggedPointer());
if (!nonpointer) {
isa.cls = cls;
} else {
assert(!DisableNonpointerIsa);
assert(!cls->instancesRequireRawIsa());
isa_t newisa(0);
#if SUPPORT_INDEXED_ISA
assert(cls->classArrayIndex() > 0);
newisa.bits = ISA_INDEX_MAGIC_VALUE;
// isa.magic is part of ISA_MAGIC_VALUE
// isa.nonpointer is part of ISA_MAGIC_VALUE
newisa.has_cxx_dtor = hasCxxDtor;
newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
newisa.bits = ISA_MAGIC_VALUE;
// isa.magic is part of ISA_MAGIC_VALUE
// isa.nonpointer is part of ISA_MAGIC_VALUE
newisa.has_cxx_dtor = hasCxxDtor;
newisa.shiftcls = (uintptr_t)cls >> 3;
#endif
// This write must be performed in a single store in some cases
// (for example when realizing a class because other threads
// may simultaneously try to use the class).
// fixme use atomics here to guarantee single-store and to
// guarantee memory order w.r.t. the class index table
// ...but not too atomic because we don't want to hurt instantiation
isa = newisa;
}
}
- 由于nonpointer传入的是true，SUPPORT_INDEXED_ISA定义为0，所以可以对这段代码简化一下：
inline void
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) {
isa_t newisa(0);
newisa.bits = ISA_MAGIC_VALUE;
newisa.has_cxx_dtor = hasCxxDtor;
newisa.shiftcls = (uintptr_t)cls >> 3;
isa = newisa;
}
② isa 初始数据
- 可以看到对bits的赋值ISA_MAGIC_VALUE = 0x001d800000000001ULL，将此转为二进制，在结合isa_t的结构得出如下的isa_t的初始数据图：
- 对 isa 赋值ISA_MAGIC_VALUE初始化实际上只是设置了indexed和magic两部分的数据：
- indexed表示 isa_t 的类型：0表示 raw isa，也就是没有结构体的部分，访问对象的 isa 会直接返回一个指向 cls 的指针，也就是在 iPhone 迁移到 64 位系统之前时 isa 的类型；1则表示当前 isa 不是指针，但是其中也有 cls 的信息，只是其中关于类的指针都是保存在 shiftcls 中。
- magic 用于调试器判断当前对象是否有初始化空间。
- 在设置indexed和magic的值后会对has_cxx_dtor进行设值。has_cxx_dtor表示该对象是否有 C++ 或者 Objc 的析构器，如果有析构函数，则需要做析构逻辑，如果没有，则可以更快的释放对象。
newisa.has_cxx_dtor = hasCxxDtor;
- 将当前对象的类指针存放在shiftcls中：
newisa.shiftcls = (uintptr_t)cls >> 3;
- 对cls的地址右移动3位的目的是为了减少内存的消耗，因为类的指针需要按照8字节对齐，也就是说类的指针的大小必定是8的倍数，其二进制后三位为0 ，右移三位抹除后面的3位0并不会产生影响。
四、isa 关联对象和类
- isa 是对象中的第一个属性，这是在继承的时候发生的，要早于对象的成员变量，属性列表，方法列表以及所遵循的协议列表。在 alloc 底层，有一个方法叫做 initIsa。这个方法的作用就是初始化 isa 联合体位域。上文中我们已经看到了这个方法：
newisa.shiftcls = (uintptr_t)cls >> 3;
- 通过 LLDB 进行调试打印，就可以知道一个对象的 isa 会关联到这个对象所属的类：
- LLDB调试的时候左移右移操作其实很好理解，先观察 isa 的 ISA_BITFIELD 位域的结构：ISA_BITFIELD 的前 3 位是 nonpointer，has_assoc，has_cxx_dtor，中间 44 位是 shiftcls ，后面 17 位是剩余的内容，同时因为 iOS 是小端模式，那么就需要去掉右边的 3 位和左边的 17位，所以就会采用 >>3<<3 然后 <<13>>13 的操作。
# elif __x86_64__
# define ISA_MASK 0x00007ffffffffff8ULL
# define ISA_MAGIC_MASK 0x001f800000000001ULL
# define ISA_MAGIC_VALUE 0x001d800000000001ULL
# define ISA_BITFIELD \
uintptr_t nonpointer : 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
五、isa 走位分析
① class object（类对象）/ metaclass（元类）
- Object-C的对象其本质就是结构体，前面也分析了每一个对象都会有一个isa。同时类的本质也是一个结构体，而且是继承自objc_object的。
struct objc_object {
private:
isa_t isa;
...
};
struct objc_class : objc_object {
// Class ISA;
Class superclass;
cache_t cache; // formerly cache pointer and vtable
class_data_bits_t bits; // class_rw_t * plus custom rr/alloc flags
...
};
- 在objc_class中也有isa：
struct objc_class : objc_object {
isa_t isa;
Class superclass;
cache_t cache; // formerly cache pointer and vtable
class_data_bits_t bits; // class_rw_t * plus custom rr/alloc flags
...
};
- class_isMetaClass用于判断Class对象是否为元类，object_getClass用于获取对象的isa指针指向的对象。
OBJC_EXPORT BOOL class_isMetaClass(Class cls)
OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0);
OBJC_EXPORT Class object_getClass(id obj)
OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0);
- 我们知道：对象可以创建多个，但是类是否可以创建多个呢？其实，类在内存中只会存在一份。
Class class1 = [Boy class];
Class class2 = [Boy alloc].class;
Class class3 = object_getClass([Boy alloc]);
Class class4 = [Boy alloc].class;
NSLog(@"\n%p-\n%p-\n%p-\n%p",class1, class2, class3, class4);
// 打印如下：
0x10edbedc8
0x10edbedc8
0x10edbedc8
0x10edbedc8
- 通过LLDB调试打印，其实可以发现：类的内存结构里面的第一个结构打印出来还是 Boy，那么是不是就意味着 对象->类->类 这样的死循环呢？这里的第二个类其实是 元类，是由系统创建的，这个元类无法被我们实例化。
- 一个实例对象通过class方法获取的Class就是它的isa指针指向的类对象，而类对象不是元类，类对象的isa指针指向的对象是元类。关系如下：
② isa 走位
- 官方的经典 isa 走位图：
- 实例对象的isa指向的是类；
- 类的isa指向的元类；
- 元类指向根元类；
- 根元类指向自己；
- NSObject的父类是nil，根元类的父类是NSObject。
- LLDB调试打印：
六、对象的本质
- OC 对象的本质就是一个结构体，在 libObjc 源码的 objc-private.h 源文件中可以看到：
struct objc_object {
private:
isa_t isa;
public:
// ISA() assumes this is NOT a tagged pointer object
Class ISA();
// getIsa() allows this to be a tagged pointer object
Class getIsa();
......
}
- 对于对象所属的类来说，也可以在 objc-runtime-new.h 源文件中找到（即 objc_class 内存中第一个位置是 isa，第二个位置是 superclass）：
struct objc_class : objc_object {
// Class ISA;
Class superclass;
cache_t cache; // formerly cache pointer and vtable
class_data_bits_t bits; // class_rw_t * plus custom rr/alloc flags
......
}
- 对象在底层其实是一个结构体 objc_object ，而Class 在底层也是一个结构体 objc_class 。