iOS底层探索系列--创建对象过程

一、查看alloc流程

编译一份objc_756的源码工程，在当前工程中创建自定义类，FLYPerson，代码如下：

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface FLYPerson : NSObject{
    NSString *hobby;
}

@property (nonatomic, copy) NSString *nickName;

- (void)sayHello;
+ (void)sayHappy;

@end

NS_ASSUME_NONNULL_END

#import "FLYPerson.h"

@implementation FLYPerson

- (void)sayHello{
    NSLog(@"FLYPerson say : Hello!!!");
}

+ (void)sayHappy{
    NSLog(@"FLYPerson say : Happy!!!");
}

@end

在main.m函数中

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

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        NSLog(@"Hello, World!");
        FLYPerson * person = [FLYPerson alloc];
        Class pClass       = object_getClass(person);
        NSLog(@"%@ - %p", person, pClass);
    }
    return 0;
}

将断点设在[FLYPerson alloc]这一行，运行程序，等断点来到此处，依次在NSObjcet.mm以下几处添加断点

此时点击下一步，会发现，代码走到

注意这里的参数，true和false，会影响到后面的代码走向。（LLVM做的一个优化，验证方法等有时间另开一篇文章讲述）

继续下一步，来到了断点列表4图中的callAlloc

cls->ISA()->hasCustomAWZ() (检测该class是否有allocWithZone方法)此时为true

最后会来到断点列表4图中1759这一行代码，继续下一步会走到断点列表3中的方法，继续下一步，依次经过_objc_rootAlloc，又来到了callAlloc，此时参数为false和true；

如果此时FLYPerson中重写了allocWithZone方法，会走到1758行[cls allocWithZone:nil]中
如果此时FLYPerson中未重写allocWithZone方法，会来到1740行if (fastpath(cls->canAllocFast()))

注意：

cls->canAllocFast() 永远为false，可以comm点击去查看，最后是根据宏定义FAST_ALLOC是否定义，如果未定义，则返回false，查看FAST_ALLOC定义除，为写死的1，永远不定义FAST_ALLOC

最后来到了如下代码：

1
2
3

id obj = class_createInstance(cls, 0);
if (slowpath(!obj)) return callBadAllocHandler(cls);
return obj;

继续，走进class_createInstance

id 
class_createInstance(Class cls, size_t extraBytes)
{
    return _class_createInstanceFromZone(cls, extraBytes, nil);
}

继续会走到calloc->initInstanceIsa,最后返回。
这里的calloc需要编译另一个工程区查看，initInstanceIsa是初始化一些参数。
最后附上一张整体流程图

二、内存对齐

三条原则：

1、数据成员对其原则：
结构（struct）（或联合体（union））的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置都要从该成员大小或者成员的子成员中占位最大（只要该成员有子成员，比如说是数组，结构体等）的整数倍开始（比如int为4个字节，则要从4的整数倍地址开始存储）。
2、结构体作为成员：
如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储。（struct a里存有struct b,b里有char，int，double等元素，那b应该从8的整数倍开始存储）。
3、最后
结构体的总大小，也就是sizeof的结构，必须是其内部最大成员的整数倍，不足的要补齐。

demo代码：

NS_ASSUME_NONNULL_BEGIN

@interface FLYTeacher : NSObject

@property (nonatomic, assign) int            age;
@property (nonatomic, assign) int            height;
@property (nonatomic, copy)   NSString   *   name;
@property (nonatomic, copy)   NSString   *   hobby;
@property (nonatomic, assign) char           des1;
@property (nonatomic, assign) char           des2;

@end

NS_ASSUME_NONNULL_END

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import <malloc/malloc.h>
#import "FLYPerson.h"
#import "FLYTeacher.h"

struct {
    double a;   // 占8位 0 - 7
    char b;     // 占1位 8 - 9
    int c;      // 占4位 12 - 15
    char d;     // 占1位 16 - 17  补齐 7位
} FLYStruct1;

struct {
    double a;  // 占8位 0 - 7
    int c;     // 占4位 8 - 11
    char b;    // 占1位 11 - 12
    char d;    // 占1位 12 - 13 补齐 3位
} FLYStruct2;

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        NSLog(@"%lu - %lu", sizeof(FLYStruct1),  sizeof(FLYStruct2));
        
        FLYTeacher * p = [FLYTeacher alloc];
        // ISA             // 占用8位
        p.age = 18;        // 占用4位
        p.height = 188;    // 占用4位
        p.name   = @"eirc";// 占用8位
        p.hobby  = @"girl";// 占用8位
        //des1             // 占用1位
        //des2             // 占用1位
        
        NSLog(@"%lu - %lu", class_getInstanceSize([p class]), malloc_size((__bridge const void *)(p)));
        
        //总和： 34 因为内存对齐，为8的整数倍，所以 class_getInstanceSize([p class]) = 40。
    }
    return 0;
}

log:
2019-12-28 11:47:32.964555+0800 FLYTest[6129:619837] 24 - 16
2019-12-28 11:47:32.965017+0800 FLYTest[6129:619837] 40 - 48

小结：

至于结构体的大小，利用上面的三原则，以及结构体后面的注释，很容易解释。
对于oc中的对象，系统已经自动为对象的属性进行了最小内存占用排序，以减少内存占用。class_getInstanceSize获取class的内存占用，malloc_size获取系统为对象开辟的空间大小，可以看到系统为对象开辟的大小比对象实际占用大小大，这样做是为了安全考虑。

这里需要查看calloc流程，通过上述过程，可以看到在calloc的时候，参数分别为1，40；
此时需要另外搭建一个libmalloc工程,在main函数中用以上参数，调用calloc函数。

#import <Foundation/Foundation.h>
#import <malloc/malloc.h>
int main(int argc, const char * argv[]) {
    @autoreleasepool {
    
    void *p = calloc(1, 40);
    NSLog(@"%lu",malloc_size(p));
    }
    return 0;
}

此处应该一直点击下一步，因为内部代码有一个递归，在递归过程中，zone->calloc重新进行了指向

上图中SHIFT_NANO_QUANTUM宏定义是4，可以看到其实就是16位对齐，得出malloc_size是16位对齐的方式开辟空间。

三、ISA

isa中存储着对象的属性，方法，类信息和引用计数等信息，可以说是一个对象的灵魂所在。

看一下创建ISA的入口：

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

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

# else

可以看到arm64中，1 + 1 + 1 + 33 + 6 + 1 + 1 + 1 + 19 = 64位，刚好8字节，x86同理。

注释：

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

总结：

isa中重要的信息都存放在shiftcls中，怎么快速获取shiftcls，就是用上面提供的掩码ISA_MASK，用掩码与isa进行与运算，结果就是shiftcls。

扩展：
这里用了位，比我们平常用的int和bool值快很多，因为位数少了很多，比如int占4个字节，arm64中就是4 * 8 = 32位，浪费了很多空间，同样效率也降低了。

最后放一张isa流程图：

总结：

对象的isa是类（类对象在内存中只有一份），类的isa是其元类，该元类的isa是NSObject的元类。NSObject的元类的isa是其自身。
元类的父类是该类的父类的元类。NSObject的元类的父类是NSObject类。NSObject类的父类是nil。