iOS 探索isa

一、OC对象的本质是什么？

可能有很多同学都知道答案，即对象的本质是结构体。但是怎么证明呢？今天我们就来一起验证下。

1、clang编译器

Clang 是⼀个由 Apple 主导编写，基于LLVM的C/C++/Objective-C编译器 。
我们主要是将其用于底层编译，将一些文件``输出成c++文件，例如main.m输出成main.cpp，其目的是为了更好的观察底层的一些结构 及 实现的逻辑，方便理解底层原理。
常见的使用方式如下:

//1、将 main.m 编译成 main.cpp
clang -rewrite-objc main.m -o main.cpp

//2、将 ViewController.m 编译成  ViewController.cpp
clang -rewrite-objc -fobjc-arc -fobjc-runtime=ios-13.0.0 -isysroot / /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator13.7.sdk ViewController.m

//以下两种方式是通过指定架构模式的命令行，使用xcode工具 xcrun
//3、模拟器文件编译
- xcrun -sdk iphonesimulator clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp 

//4、真机文件编译
- xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main- arm64.cpp 

2、对象的本质

接下来我们就来使用一下：

1)定义一个类LPPerson，LPPerson有一个属性name

#import <Foundation/Foundation.h>
#import <objc/runtime.h>


@interface LPPerson : NSObject
@property (nonatomic, copy) NSString *name;
@end

@implementation LPPerson
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
    }
    return 0;
}

2)接下来我们运用clang将main.m编译成C++文件main.cpp

在终端中进入main.m所在目录，并使用clang -rewrite-objc main.m -o main.cpp命令即可：

image.png
可以再main.m的目录中发现main.cpp，双击打开main.cpp： image.png
image.png

可以看到，编译出来的main.mm文件很大，11万多行，看着就很懵逼是不是？其实我们不用看所有的代码，记得我们刚才申明了LPPerson吗？我们在代码里面搜索下，找到如下代码：

#ifndef _REWRITER_typedef_LPPerson
#define _REWRITER_typedef_LPPerson
typedef struct objc_object LPPerson;
typedef struct {} _objc_exc_LPPerson;
#endif

extern "C" unsigned long OBJC_IVAR_$_LPPerson$_name;
struct LPPerson_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    NSString *_name;
};

// @property (nonatomic, copy) NSString *name;
/* @end */


// @implementation LPPerson

static NSString * _I_LPPerson_name(LPPerson * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_LPPerson$_name)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);

static void _I_LPPerson_setName_(LPPerson * self, SEL _cmd, NSString *name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct LPPerson, _name), (id)name, 0, 1); }
// @end

可以看到OC中的LPPerson变成了struct LPPerson_IMPL，这也就印证了OC对象是结构体。
但是NSObject_IMPL是什么东东？struct NSObject_IMPL NSObject_IVARS;这个又是什么意思？搜索一下NSObject_IMPL，会发现有很多，无法定位，那我们直接搜索这个结构的定义struct NSObject_IMPL {，结果出现了：

struct NSObject_IMPL {
    Class isa;
};

在结合Objc源码中对NSObject的定义：

@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
    Class isa  OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}

我们可以得到结论：

• NSObject的底层实现实质是一个结构体
• 结构体中的第一个成员是 isa指针，并且isa是Class类型，因为LPPerson中的第一个属性NSObject_IVARS等效于 NSObject中的 isa

3、探索objc_setProperty原理

除了LPPersong的底层定义，我们发现还有属性name对应的set和 get方法，如下图所示，其中set方法的实现依赖于runtime中的objc_setProperty:

image.png

所以我们接下来了解下objc_setProperty，在Objc源码中查找objc_setProperty：

void objc_setProperty(id self, SEL _cmd, ptrdiff_t offset, id newValue, BOOL atomic, signed char shouldCopy) 
{
    bool copy = (shouldCopy && shouldCopy != MUTABLE_COPY);
    bool mutableCopy = (shouldCopy == MUTABLE_COPY);
    reallySetProperty(self, _cmd, newValue, offset, atomic, copy, mutableCopy);
}

再进入reallySetProperty中：

image.png

我们可以发现其方法的原理就是retain新值，release旧值，基于这段源码我们可以了解到：

• objc_setProperty方法的目的适用于关联 上层的set方法 以及 底层的set方法，其本质就是一个接口。

• 这么设计的原因是，上层的set方法有很多，如果直接调用底层set方法中，会产生很多的临时变量，当你想查找一个sel时，会非常麻烦

• 基于上述原因，苹果采用了适配器设计模式（即将底层接口适配为客户端需要的接口），对外提供一个接口，供上层的set方法使用，对内调用底层的set方法，使其相互不受影响，即无论上层怎么变，下层都是不变的，或者下层的变化也无法影响上层，主要是达到上下层接口隔离的目的

二、探索isa

在探索isa之前我们先了解点预备知识：

1、联合体和结构体：

构造数据类型的方式有以下两种：

1)结构体（struct）

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

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

2)联合体（union，也称为共用体）

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

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

3)两者的区别:

• 内存占用情况

结构体：各个成员会占用不同的内存，互相之间没有影响
联合体：所有成员占用同一段内存，修改一个成员会影响其余所有成员

• 内存分配大小

结构体内存： 所有成员占用的内存总和（成员之间可能会有缝隙）
联合体：占用的内存等于最大的成员占用的内存

2、isa_t

isa的类型是isa_t，我们再Objc中查看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实际上就是一个联合体。
isa_t类型使用联合体的原因也是基于内存优化的考虑，这里的内存优化是指在isa指针中通过char + 位域（即二进制中每一位均可表示不同的信息）的原理实现。通常来说，isa指针占用的内存大小是8字节，即64位，已经足够存储很多的信息了，这样可以极大的节省内存，以提高性能

从isa_t的定义中可以看出：

提供了两个成员，cls和 bits，由联合体的定义所知，这两个成员是互斥的，也就意味着，当初始化isa指针时，有两种初始化方式:

• 通过cls初始化，bits无默认值
• 通过bits初始化，cls有默认值

还提供了一个结构体定义的位域，用于存储类信息及其他信息，结构体的成员ISA_BITFIELD，这是一个宏定义，有两个版本 __arm64__（对应ios 移动端） 和 __x86_64__（对应macOS），以下是它们的一些宏定义，如下图所示

#   define ISA_BITFIELD                                                        \
        //针对isa指针的指针优化
      uintptr_t nonpointer        : 1;                                        \
        //是否被关联
      uintptr_t has_assoc         : 1;                                   \
        //是否有C++相关实现
      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

具体意义：

nonpointer有两个值，表示自定义的类等，占1位

• 0：纯isa指针
• 1：不只是类对象地址，isa中包含了类信息、对象的引用计数等

has_assoc表示关联对象标志位，占1位

• 0：没有关联对象
• 1：存在关联对象

has_cxx_dtor表示该对象是否有C++/OC的析构器（类似于dealloc），占1位

• 如果有析构函数，则需要做析构逻辑
• 如果没有，则可以更快的释放对象

shiftclx表示存储类的指针的值（类的地址）， 即类信息

• arm64中占 33位，开启指针优化的情况下，在arm64架构中有33位用来存储类指针
• x86_64中占 44位

magic 用于调试器判断当前对象是真的对象 还是 没有初始化的空间，占6位

weakly_refrenced是 指对象是否被指向 或者 曾经指向一个ARC的弱变量

• 没有弱引用的对象可以更快释放

deallocating 标志对象是是否正在释放内存

has_sidetable_rc表示 当对象引用计数大于10时，则需要借用该变量存储进位

extra_rc（额外的引用计数） --- 表示该对象的引用计数值，实际上是引用计数值减1

• 如果对象的引用计数为10，那么extra_rc为9，
• 如果引用计数大于10，则需要使用到下面的has_sidetable_rc

isa的创建

接下里我们来看下isa是如何创建的，在Objc源码中直接搜索initInstanceIsa或者，刚才搜索isa_t的时候，第一个出现的结果就是initInstanceIsa中：

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   //等效于!nonpointer
        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                   //等效于nonpointer
        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;
    }
}

这里也证明了我们之前说的cls和Bits是互斥的，所以isa的初始化会二选一：

• 通过cls初始化isa
• 通过bits初始化isa

三、isa和类的关联

cls与isa关联原理就是isa指针中的shiftcls位域中存储了类信息，其中initInstanceIsa的过程是将calloc指针和当前的类cls关联起来了。

觉得不错记得点赞哦！听说看完点赞的人逢考必过，逢奖必中。ღ( ´･ᴗ･` )比心