iOS-底层（5）：isa如何与类关联

首先我们需要了解OC对象的本质是什么？

OC对象的本质

我们在探索对象的本质时，通常会用到一个东西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关键字。Clang是一个C++编写、基于LLVM、发布于LLVM BSD许可证下的C/C++/Objective-C/Objective-C++编译器。它与GNUC语言规范几乎完全兼容（当然，也有部分不兼容的内容，包括编译命令选项也会有点差异），并在此基础上增加了额外的语法特性，比如C函数重载（通过attribute（overloadable））来修饰函数），其目标（之一）就是超越GCC。

首先我们定义一个对象

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

@implementation FYPerson
@end

• 通过终端利用clang将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 

• 打开编译好的main.cpp，找到FYPerson的定义，可以看到FYPerson在底层会被编译成 struct 结构体

1. NSObject的底层编译

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

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

2. FYPerson的底层编译

struct FYPerson_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    NSString *_name;
};

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


// @implementation FYPerson

//这是get方法
static NSString * _I_FYPerson_name(FYPerson * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_FYPerson$_name)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);

//这是set方法
static void _I_FYPerson_setName_(FYPerson * self, SEL _cmd, NSString *name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct FYPerson, _name), (id)name, 0, 1); }
// @end

通过上述分析我们的出结论：

• OC对象的本质就是一个结构体

• 结构体在C++是可以继承的，在c可以伪继承，FYPerson_IMPL中的第一个属性其实就是isa，是继承自NSObject，属于伪继承，伪继承的方式是直接将NSObject结构体定义为FYPerson中的第一个属性，意味着FYPerson 拥有 NSObject中的所有成员变量。

FYPerson中的第一个属性 NSObject_IVARS 等效于 NSObject中的 isa

我们看到C++的set方法的实现，这里有个比较有意思的设计模式给大家拓展一下，就是适配器

适配器

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。

对于的set方法来说，本质就是retain新值，release旧值，我们提供统一的接口可以让所有的set方法都调用这个函数，我们看看苹果是怎么做的

• set方法的实现依赖于runtime中的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的源码实现

static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
{
    if (offset == 0) {
        object_setClass(self, newValue);//设置新值
        return;
    }

    id oldValue;
    id *slot = (id*) ((char*)self + offset);

    if (copy) {
        newValue = [newValue copyWithZone:nil];
    } else if (mutableCopy) {
        newValue = [newValue mutableCopyWithZone:nil];
    } else {
        if (*slot == newValue) return;
        newValue = objc_retain(newValue);//新值retrain
    }

    if (!atomic) {
        oldValue = *slot;
        *slot = newValue;
    } else {
        spinlock_t& slotlock = PropertyLocks[slot];
        slotlock.lock();
        oldValue = *slot;
        *slot = newValue;        
        slotlock.unlock();
    }

    objc_release(oldValue);//旧值release
}

总结

• 每一个set方法都做相同的事情：新值的retain，旧值的release，我们通过适配器模式，设计一个接口，做一个中间层的隔离
• 上层的set方法有很多，如果直接调用底层set方法中，会产生很多的临时变量，当你想查找一个sel时，会非常麻烦
• 苹果采用了适配器设计模式，将底层接口适配为客户端需要的接口，对外提供一个接口，供上层的set方法使用，对内调用底层的set方法，使其相互不受影响，即无论上层怎么变，下层都是不变的，或者下层的变化也无法影响上层，主要是达到上下层接口隔离的目的

1. 上层setXXX
2. 接口隔离层objc_setProperty，通过传入的cmd区分不同的set方法
3. 下层reallySetProperty

联合体位域

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
};

struct objc_object {
private:
    isa_t isa;
}

为什么isa的类型isa_t是使用联合体定义的呢，首先我们来了解一下什么是联合体

结构体（struct）中所有变量是"共存"的，变量不管是否使用，都会分配内存。

• 优点是"有容乃大"，全面
• 缺点是struct内存空间的分配是粗放的，不管用不用，全分配。

联合体（union）中是各变量是"互斥"的，所有的成员共占一段内存。而且共用体采用了内存覆盖技术，同一时刻只能保存一个成员的值，如果对新的成员赋值，就会将原来成员的值覆盖掉

• 缺点就是不够"包容"
• 但优点是内存使用更为精细灵活，也节省了内存空间

isa的类型 isa_t

union isa_t { //联合体
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }
    //提供了cls 和 bits ，两者是互斥关系
    Class cls;
    uintptr_t bits;
#if defined(ISA_BITFIELD)
    struct {
        ISA_BITFIELD;  // defined in isa.h
    };
#endif
};

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

从isa_t的定义中可以看出：

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

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

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

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

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

#   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)

# else
#   error unknown architecture for packed isa
# endif

// SUPPORT_PACKED_ISA
#endif

• 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

s.001.jpeg

原理探索

通过alloc --> _objc_rootAlloc --> callAlloc --> _objc_rootAllocWithZone --> _class_createInstanceFromZone方法路径，查找到initInstanceIsa，并进入其原理实现

inline void 
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
    ASSERT(!cls->instancesRequireRawIsa());
    ASSERT(hasCxxDtor == cls->hasCxxDtor());
    //初始化isa
    initIsa(cls, true, hasCxxDtor); 
}

进入initIsa方法的源码实现

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 与 类 的关联

image.png image.png

isa & ISA_MASK 也就是抹零操作算法，得出 shiftcls，也就是FYPerson，所以类信息存到了isa里，也就产生了关联。

我们再来看一下 isa 明明是 isa_t 类型，那NSobject 为什么定义为 Class isa 呢？

- (Class)class {
    return object_getClass(self);
}

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);也就是通过算法得到shiftcls强转为Class，所以才在外层表示为Class。