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

OC对象的本质

在弄清对象本质之前，我们先了解一个东西，叫做clang。

clang

clang定义

Clang是一个C语言、C++、Objective-C语言的轻量级编译器。源代码发布于BSD协议下。Clang将支持其普通lambda表达式、返回类型的简化处理以及更好的处理constexpr关键字。

Clang是一个由Apple主导编写，基于LLVM的C/C++/Objective-C编译器

2013年4月,Clang已经全面支持C++11标准，并开始实现C++1y特性（也就是C++14，这是C++的下一个小更新版本）。Clang将支持其普通lambda表达式、返回类型的简化处理以及更好的处理constexpr关键字。^[2]

Clang是一个C++编写、基于LLVM、发布于LLVM BSD许可证下的C/C++/Objective-C/Objective-C++编译器。它与GNU C语言规范几乎完全兼容（当然，也有部分不兼容的内容，包括编译命令选项也会有点差异），并在此基础上增加了额外的语法特性，比如C函数重载（通过attribute((overloadable))来修饰函数），其目标（之一）就是超越GCC。^[1]

clang用法

首先打开终端，并cd到我们要查看的文件的上级目录

cd到上级目录.png
添加代码如下:

//这段代码的含义是把main.m编译成main.cpp
clang -rewrite-objc main.m -o main.cpp

执行.png

点击回车执行。

执行完成后如下:

执行完成.png

最后可以看到在目录中出现了main.cpp文件

结果.png

我们在main.cpp中全局搜搜LGPerson,最终会看到如下代码

//NSObject_IMPL
struct NSObject_IMPL {
    Class isa;
};

//LGPerson
#ifndef _REWRITER_typedef_LGPerson
#define _REWRITER_typedef_LGPerson
typedef struct objc_object LGPerson;
typedef struct {} _objc_exc_LGPerson;
#endif

extern "C" unsigned long OBJC_IVAR_$_LGPerson$_name;
struct LGPerson_IMPL {
    struct NSObject_IMPL NSObject_IVARS;     // 等效于 Class isa;
    NSString *_name;
};

可以看到，所以OC对象的本质为结构体，NSObject_IMPL为 NSObject的结构体，每个OC实例都会包含一个继承自NSObject的 isa 指针。

而且由于存在name这个属性，所以也会自动帮我们生成getter、setter方法。

//getter方法
static NSString * _I_LGPerson_name(LGPerson * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_LGPerson$_name)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);
//setter方法
static void _I_LGPerson_setName_(LGPerson * self, SEL _cmd, NSString *name) {
    objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct LGPerson, _name), (id)name, 0, 1); }

所有的setter方法在底层的实质都是调用了objc_setProperty方法，通过一个接口来进行底层的调用，以达到解耦的目的。

联合体

我们知道对象内存的大小决定于属性。
假如我们有一个对象LGCar

@interface LGCar : NSObject

@property (nonatomic, assign) bool front;
@property (nonatomic, assign) bool back;
@property (nonatomic, assign) bool left;
@property (nonatomic, assign) bool right;

它有4个属性，那么它的大小就是2 * 4 = 8个字节，64位。
那么可以这样来表示，我们定义一块内存

//定义内存
0000 0000

第一位表示front是或者否

//是
0000 0001
//否
0000 0000

第二位表示back是或者否

//是
0000 0010
//否
0000 0000

第三位表示left是或者否

//是
0000 0100
//否
0000 0000

第四位表示right是或者否

//是
0000 1000
//否
0000 0000

那么，我们就可以用以下的代码来描述上面的行为

    // 联合体
    union {
        char bits;
        // 位域
        struct { // 0000 1111
            char front  : 1;
            char back   : 1;
            char left   : 1;
            char right  : 1;
        };
    } _direction;

而其中bits就用来存储4个属性当前的状态，这就是所谓的联合体位域。

结构体

结构体(struct)中所有变量是“共存”的——优点是“有容乃⼤”，
全⾯；
联合体(union)中是各变量是“互斥”的——缺点就是不够“包容”；
但优点是内存使⽤更为精细灵活，也节省了内存空间。

isa

接下来，我们来研究isa，我们还是通过之前的iOS底层原理--alloc&init&new这篇文章一直往下追随，最终看到如下代码:

inline void 
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) 
{ 
    ASSERT(!isTaggedPointer()); 
    
    if (!nonpointer) {
        isa = isa_t((uintptr_t)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;
    }
}

那么，通过上面一段代码我们可以看到，isa最终是由isa_t复制而来，

//赋值给isa
isa = isa_t((uintptr_t)cls);

那么，我们来看看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
};

由上面代码可以看到，isa_t也是一个联合体。在这个联合体中cls和bits是互斥的，即只能存在一个。
我们来看具体的结构体ISA_BITFIELD

//真机环境
# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
#   define ISA_MAGIC_MASK  0x000003f000000001ULL
#   define ISA_MAGIC_VALUE 0x000001a000000001ULL
#   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
#   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
#   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)

假如我们在__arm64__环境下，我们可以看到ISA_BITFIELD加起来有64位，就是8个字节，再次证实了isa是8字节的。
每位所代表的含义如下：

名称	含义	位数
nonpointer	表示是否对 isa 指针开启指针优化（0：纯isa指针，1：不⽌是类对象地址,isa 中包含了类信息、对象的引⽤计数等）	1
has_assoc	关联对象标志位，0没有，1存在	1
has_cxx_dtor	该对象是否有 C++ 或者 Objc 的析构器,如果有析构函数,则需要做析构逻辑, 如果没有,则可以更快的释放对象	1
shiftcls	存储类指针的值。开启指针优化的情况下，在 arm64 架构中有 33 位⽤来存储类指针。	33
magic	⽤于调试器判断当前对象是真的对象还是没有初始化的空间	6
weakly_referenced	指对象是否被指向或者曾经指向⼀个 ARC 的弱变量，没有弱引⽤的对象可以更快释放。	1
deallocating	标志对象是否正在释放内存	1
has_sidetable_rc	当对象引⽤技术⼤于 10 时，则需要借⽤该变量存储进位	1
extra_rc	当表示该对象的引⽤计数值，实际上是引⽤计数值减 1，例如，如果对象的引⽤计数为 10，那么 extra_rc 为 9。如果引⽤计数⼤于 10，则需要使⽤到 has_sidetable_rc。	19

在__arm64__和__x86_64__环境下isa的分布图如下：

isa.png

我们知道obj->initInstanceIsa(cls, hasCxxDtor);方法的实质就是将类和isa进行关联,其实就是这么一句代码。

//shiftcls 存储类信息
//cls就是LGPerson类
 newisa.shiftcls = (uintptr_t)cls >> 3;

那么我们来证明一下：
首先我们打印(uintptr_t)cls >> 3的信息，因为在shiftcls之前有三位，所以需要右移三位

cls.png

然后打印下newisa信息

newisa.png

可以看到，已经把cls存入到newisa中了，而且cls= LGPerson。

现在进行反推，如下的代码

objc2.png

我们打印一下objc2信息

objc2.png

因为第一位是isa信息，所以isa为0x001d8001000020e9,
接下来，我们和ISA_MASK进行与运算，如图

ISA_MASK.png

为什么是ISA_MASK呢？
我们用科学计算机打印一下，可以看到，从第三位开始后的33位都为1，其他位都为0，计算后得到的数据正好可以得到从3位开后33位的值

ISA_MASK.png

最终得到结果，经过与运算后得到的正是LGPerson

LGPerson.png

结论

通过上面的计算，我们可以知道，isa包含了Class类，从而将isa与Class类进行了关联。