IOS底层原理之isa

在上一篇的文章深入底层理解alloc和init以及new中我们分析了alloc，知道了 alloc创建了对象并且分配内存；同时初始化isa属性；我们也知道了Objective-C 对象在底层本质上是结构体，所有的对象里面都会包含有一个isa，isa的定义是一个联合体isa_t，isa_t包含了当前对象指向类的信息，这篇文章我们来分析探究isa。

联合体isa_t

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)

这是在 __x86_64__ 上的实现，__arm64__的架构会有所差别，但是这些字段都还是有的，并不影响我们对于isa_t的分析。

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_t是一个64位的联合，isa占用8个字节的大小。下面我们来分下下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;
}

从上面这段代码中我们看到的是对bits的赋值ISA_MAGIC_VALUE=0x001d800000000001ULL,将此转为二进制，在结合isa_t的结构得出如下的isa_t的初始数据图。

ISA_MAGIC_VALU二进制

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并不会产生影响。

bits中的其他说明

has_assoc 对象含有或者曾经含有关联引用，没有关联引用的可以更快地释放内存

weakly_referenced 对象被指向或者曾经指向一个 ARC 的弱变量，没有弱引用的对象可以更快释放

deallocating 对象正在释放内存

has_sidetable_rc 当对象引用技术大于 10 时，则需要借用该变量存储进位。

extra_rc 表示该对象的引用计数值，实际上是引用计数值减 1，例如，如果对象的引用计数为 10，那么 extra_rc 为 9。如果引用计数大于 10，则需要使用到下面的 has_sidetable_rc。

通过上面的分析我们知道了，alloc在创建对象分配内存后会进行isa的初始化，isa中存储了对象或者类的一些信息。下面我们来分析下isa和类、对象之间的关系。

isa的走位

我们都知道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
...
};

我们通通过一幅图来分析下isa、对象、类之间的关系。

实例对象的isa指向的是类；
类的isa指向的元类；
元类指向根元类；
根元类指向自己；
NSObject的父类是nil，根元类的父类是NSObject。

下面我来验证下他们之间的关系