iOS开发底层探究之路

isa 与类关联原理探究

在探究isa之前，先要理清一个概念：对象是什么？对象的本质是什么？
首先来了解一下Clang：

Clang是由Apple主导编写，是一个C语言、C++、Objective-C语言的轻量级编译器。

因为Objective-C是C、C++的超集，所以想要看到OC底层源码结构，我们需要借助Clang 编译器来查看底层实现。

1.对象的本质探究

创建工程，在main.m中添加LGPerson 类，如下图：

探究对象本质

打开终端，定位到当前main.m文件位置，在终端输入clang -rewrite-objc main.m -o main.cpp，可以看到在main.m文件位置发现多了一个main.cpp文件：

终端生成main.cpp文件

打开main.cpp 文件，查找我们的LGPerson，如下所示：

main.cpp中的LGPerson是啥？

从上图可知，LGPerson类对象在底层中被编译成了一个struct结构体。
因为在C++中结构体是可以继承的，LGPerson_IMPL中的第一个属性其实就是 isa，是继承自NSObject，属于伪继承，伪继承的方式是直接将NSObject结构体定义为LGPerson中的第一个属性，意味着LGPerson 拥有 NSObject中的所有成员变量。

//NSObject的定义
@interface NSObject <NSObject> {
    Class isa  OBJC_ISA_AVAILABILITY;
}

//NSObject 的底层编译
struct NSObject_IMPL {
    Class isa;
};

//LGPerson的底层编译
struct LGPerson_IMPL {
    struct NSObject_IMPL NSObject_IVARS; // 等效于 Class isa;
    NSString *_name;
};

总结

OC对象的本质就是结构体 .
LGPerson中的isa就是继承自NSObject中的isa.

2.objc_setProperty 探究

上面所展示的main.cpp中LGPerson相关信息中，我们还看到属性变量name的set和get方法，如下图所示：

属性的get与set

可以看到，set方法是通过Runtime 中的objc_setProperty方法实现的。
现在我们来看看这个objc_setProperty是如何一步一步实现的：

在objc4_781源码中全局搜索objc_setProperty，找到如下：

objc_setProperty实现
接着，我们继续进入reallySetProperty方法：

reallySetProperty实现

通过查看objc_setProperty方法的实现，发现上层属性的set方法到底层的set方法经过objc_setProperty方法处理之后，已经失去了痕迹，只是带进来了每个set方法特有的_cmd，可想而知，objc_setProperty就是上层set和下层set的一个中间关联层。

objc_setProperty 是关联上层set和下层set的一个中间接口。
这么设计的原因是，大量的上层set会产生大量的临时变量。
基于上述原因，苹果采用了适配器设计模式（即将底层接口适配为客户端需要的接口），对外提供一个接口，供上层的set方法使用，对内调用底层的set方法，使其相互不受影响，即无论上层怎么变，下层都是不变的，或者下层的变化也无法影响上层，主要是达到上下层接口隔离的目的。
大致可以用下图表示上层、接口隔离层、底层关系：

上层、接口隔离层、底层关系

3. isa类型isa_t分析

在分析isa_t之前我们先了解一下联合体和结构体的区别：

结构体

结构体是指把不同的数据组合成一个整体，其变量是共存的，变量不管是否使用，都会分配内存。

缺点：所有属性都分配内存，比较浪费内存，假设有4个int成员，一共分配了16字节的内存，但是在使用时，你只使用了4字节，剩余的12字节就是属于内存的浪费。
优点：存储容量较大，包容性强，且成员之间不会相互影响。

联合体

联合体也是由不同的数据类型组成，但其变量是互斥的，所有的成员共占一段内存。而且共用体采用了内存覆盖技术，同一时刻只能保存一个成员的值，如果对新的成员赋值，就会将原来成员的值覆盖掉。

缺点：包容性弱。
优点：所有成员共用一段内存，使内存的使用更为精细灵活，同时也节省了内存空间。

两者的区别

内存占用情况
- 结构体的各个成员会占用不同的内存，互相之间没有影响
- 共用体的所有成员占用同一段内存，修改一个成员会影响其余所有成员
内存分配大小
- 结构体内存 >= 所有成员占用的内存总和（成员之间可能会有缝隙）
- 共用体占用的内存等于最大的成员占用的内存

下面我们就来分析分析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
};

isa的类型isa_t上图所示，是一个union联合体。使用联合体的原因，是为了节省内存，这里的内存优化是指在isa指针中通过char + 位域（即二进制中每一位均可表示不同的信息）。

isa_t联合体提供了两个成员，cls和 bits ，他们的关系的互斥的，但是根据联合体的定义（从前往后排列），初始化isa时，会有两种方式：
- 通过cls初始化，bits无默认值。
- 通过bits初始化，cls有默认值。
isa_t还提供了一个结构体类型的位域，用于存储类信息及其他信息，结构体的成员ISA_BITFIELD，这是一个宏定义，有两个版本 __arm64__（对应ios移动端）和 __x86_64__（对应macOS），以下是它们的一些宏定义，如下图所示

ISA_BITFIELD结构图
nonpointer：表示是否对isa指针开启指针优化
- 0:纯isa指针
- 1:不止是类对象地址，isa中包含了类信息、对象的引用计数等
has_assoc：关联对象标志位
- 0：没有关联对象
- 1：存在关联对象
has_cxx_dtor：该对象是否有C++或者Objc的析构器，如果有析构函数，在对象释放的时候就需要做析构处理，没有的话则会释放的更快
shiftcls：存储类指针的值。开启指针优化的情况下，在arm64架构中有33位用来存储类指针
magic：用于调试器判断当前对象是真的对象还是没有初始化的空间
weakly_referenced：此对象是否指向或者曾经指向一个ARC的弱变量，没有弱引用的话，能更快地释放对象
deallocation：标志对象是否正在释放内存
has_sidetable_rc：当对象引用计数大于10时，则需要借用该变量存储计数
extra_rc：当表示该对象的引用计数值，实际上是引用计数值减1，例如，如果对象的引用计数为10，那么extra_rc为9。如果引用计数大于10，则需要使用到下面的has_sidetable_rc。

4.isa初始化探究

下面我们就来看看isa_t类型的isa初始化情况，跟踪源码alloc底层实现我们来到initInstanceIsa方法，

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 = isa_t((uintptr_t)cls);//通过 cls 初始化isa 
    } else {
        ASSERT(!DisableNonpointerIsa);
        ASSERT(!cls->instancesRequireRawIsa());

        isa_t newisa(0);//通过 

#if SUPPORT_INDEXED_ISA  //  0 
        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;  //初始化 bits 信息
        // 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;//初始化 shiftcls信息
#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;
    }
}

initIsa 方法就是通过两种不同的初始化方式来初始化isa,根据nonpointer来判断。

5.isa与类的关联

调试跟踪上图的isa初始化过程,可以分析处isa是如何一步一步与类关联起来的,首先打下断点，一步一步调试：

5.1 isa初始化调试

断点p打印结果分别为：

(lldb) p newisa
(isa_t) $0 = {
  cls = nil
  bits = 0
   = {
    nonpointer = 0
    has_assoc = 0
    has_cxx_dtor = 0
    shiftcls = 0
    magic = 0
    weakly_referenced = 0
    deallocating = 0
    has_sidetable_rc = 0
    extra_rc = 0
  }
}
(lldb) p newisa
(isa_t) $1 = {
  cls = 0x001d800000000001
  bits = 8303511812964353
   = {
    nonpointer = 1
    has_assoc = 0
    has_cxx_dtor = 0
    shiftcls = 0
    magic = 59
    weakly_referenced = 0
    deallocating = 0
    has_sidetable_rc = 0
    extra_rc = 0
  }
}
(lldb) p newisa
(isa_t) $2 = {
  cls = LGPerson
  bits = 8303516107940081
   = {
    nonpointer = 1
    has_assoc = 0
    has_cxx_dtor = 0
    shiftcls = 536871966
    magic = 59
    weakly_referenced = 0
    deallocating = 0
    has_sidetable_rc = 0
    extra_rc = 0
  }
}

三步打印结果为下图所示：

5.2 isa初始化三部曲

综上所述，最后一个断点即isa初始化结束时，已经可以看出isa的cls即为LGPerson，且isa中的指针的shiftcls中存储了类的信息，那接下来我们可以通过几种方式验证一下：

1.通过initIsa方法中的newisa.shiftcls = (uintptr_t)cls >> 3;验证
2.通过isa指针地址与ISA_MSAK 的值 & 来验证
3.通过runtime的方法object_getClass验证
4.通过位运算验证

方式一：断点停在1位置，lldb命令p打印(uintptr_t)cls及 (uintptr_t)cls >> 3，然后继续停在断点3位置，p newisa发现此时isa中的shiftcls的值刚好与(uintptr_t)cls >> 3 相等，而且cls与LGPerson绑定上了。

拓展：

为什么在shiftcls赋值时需要类型强转？

因为内存的存储不能存储字符串，机器码只能识别0 、1这两种数字，所以需要将其转换为uintptr_t数据类型，这样shiftcls中存储的类信息才能被机器码理解，其中uintptr_t是long

为什么需要右移3位？

主要是由于shiftcls处于isa指针地址的中间部分，前面还有3个位域，为了不影响前面的3个位域的数据，需要右移将其抹零。

方式二：回到_class_createInstanceFromZone方法中，我们在return obj前打下断点：

利用 x/4gx 获取当前obj的指针地址，然后进行& ISA_MASK 操作。

方式三：通过runtime的api，即object_getClass函数获取类信息
查看object_getClass函数源码的实现：

Class object_getClass(id obj)
{
    if (obj) return obj->getIsa();
    else return Nil;
}

inline Class 
objc_object::getIsa() 
{
    if (fastpath(!isTaggedPointer())) return ISA();

    extern objc_class OBJC_CLASS_$___NSUnrecognizedTaggedPointer;
    uintptr_t slot, ptr = (uintptr_t)this;
    Class cls;

    slot = (ptr >> _OBJC_TAG_SLOT_SHIFT) & _OBJC_TAG_SLOT_MASK;
    cls = objc_tag_classes[slot];
    if (slowpath(cls == (Class)&OBJC_CLASS_$___NSUnrecognizedTaggedPointer)) {
        slot = (ptr >> _OBJC_TAG_EXT_SLOT_SHIFT) & _OBJC_TAG_EXT_SLOT_MASK;
        cls = objc_tag_ext_classes[slot];
    }
    return cls;
}

inline Class 
objc_object::ISA() 
{
    ASSERT(!isTaggedPointer()); 
#if SUPPORT_INDEXED_ISA
    if (isa.nonpointer) {
        uintptr_t slot = isa.indexcls;
        return classForIndex((unsigned)slot);
    }
    return (Class)isa.bits;
#else
    return (Class)(isa.bits & ISA_MASK); 
#endif
}

(Class)(isa.bits & ISA_MASK);，强转而且此步还进行了 & 操作，这与方式二中的原理是一致的，获得当前的类信息

方式四：位运算
回到_class_createInstanceFromZone方法中，x/4gx打印此时obj的存储信息，此时isa中的shiftcls此时占44位（因为处于macOS环境

位运算验证方式

首先，通过x/4gx obj获取当前obj 的存储信息，拿到指针地址0x001d8001000020f1
p/x 0x001d8001000020f1 >> 3 右移三位，右边三位抹0
p/x 0x0003b0002000041e << 20 左移20位，因为之前右移3位后，最左边补了3位0，加上之前的17位，所以想要抹掉左边的，必须左移20位
p/x 0x0002000041e00000 >> 17 最后右移17，使存储信息的shiftcls回到原来的位置。
最后利用p/x cls打印结果地址刚好与上方位运算结果一致。

iOS底层 - isa与类关联的原理