• Runtime源码解析-alloc
  • 前言
  • alloc
    • 通过汇编查看调用流程
    • 1. objc_alloc方法
    • 2. callAlloc方法
      • 首次进入
      • 非首次进入
      • LLVM优化
    • 3. _objc_rootAllocWithZone方法
    • 4. _class_createInstanceFromZone方法
      • instanceSize：计算内存大小
        • fastInstanceSize
        • alignedInstanceSize
      • malloc/calloc：开辟内存
      • initInstanceIsa/initIsa：内存和类关联
    • 总结
  • init
  • new

Runtime源码解析-alloc

前言

• 从这篇文章开始，我们进行OC底层研究。主要研究方向包括了：对象和类的具体实现，属性、方法、协议等是如何存储的，方法是如何调用，类和category是如何加载，weak是如何实现的等等一些问题
• 本系列博客所用的是818.2版本的objc4源码(目前最新版)

alloc

• 在我们iOS的开发过程中，使用最频繁的就是alloc一个对象，那alloc到底做了些什么？那就让我们从alloc开始，开启oc的底层研究之路。
• 首先我们创建一个Test类

@interface Test : NSObject@end@implementation Test@end- (void)viewDidLoad {[super viewDidLoad];Test *test = [Test alloc];
}

• 一般习惯性我们会点击alloc的实现，发现进去只能看到声明，看不到具体实现。由于我们写的都是高级语言，最终都会编译成汇编。所以我们可以通过汇编来查看具体调用。

通过汇编查看调用流程

• 首先通过Debug -> Debug Workflow -> Always Show Disassembly，打开汇编
• 然后在Test *test1 = [Test alloc];添加断点。

• 运行起来后，我们发现alloc调用的是objc_alloc方法。然后按住control键+step into，执行到objc_alloc里面去了

• 发现直接进入libobjc.A.dylib中，调用了_objc_rootAllocWithZone方法。既然知道方法在lib库中，这个时候我们就进入到objc4源码中。

1. objc_alloc方法

id
objc_alloc(Class cls)
{return callAlloc(cls, true/*checkNil*/, false/*allocWithZone*/);
}

• 内部调用了callAlloc方法

2. callAlloc方法

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__ // 判断是否是否objc2.0版本，目前所采用都是2.0版本if (slowpath(checkNil && !cls)) return nil;if (fastpath(!cls->ISA()->hasCustomAWZ())) {return _objc_rootAllocWithZone(cls, nil);}
#endif// No shortcuts available.if (allocWithZone) {return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);}return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
}

• 首先遇到两个宏判断

#define fastpath(x) (__builtin_expect(bool(x), 1)) // fastpath(x):x很可能为真 
#define slowpath(x) (__builtin_expect(bool(x), 0)) // slowpath(x):x很可能为假，为真的概率很小 

• 作用是告诉编译器可能的结果，可以优化编译器的速度。
• 通过编译调试可知
  • 首次进入callAlloc方法，会调用((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));方法。
    • 这里objc_msgSend是iOS中消息转发机制，最终会调用alloc这个方法
  • 第二次进入，会走_objc_rootAllocWithZone方法。

首次进入

• 会接着进入alloc方法

+ (id)alloc {return _objc_rootAlloc(self);
}

• 进入_objc_rootAlloc方法

id
_objc_rootAlloc(Class cls)
{return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

• 再次进入callAlloc方法

非首次进入

• 会直接进入_objc_rootAllocWithZone方法

LLVM优化

• 这里为什么会走两次callAlloc方法？为什么alloc方法需要先调用objc_alloc然后再调用alloc。
• 这里是苹果在LLVM中做了操作，会给alloc方法，添加一个hook方法objc_alloc。让每第一次走到alloc方法，都先走到object_alloc方法。只有走过这个方法后，再去调用真正的alloc方法。
• 苹果在objc_alloc方法做一些额外操作，比如ARC相关，类型转换等，方便苹果做一些监控，以及优化。

3. _objc_rootAllocWithZone方法

NEVER_INLINE
id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{// allocWithZone under __OBJC2__ ignores the zone parameterreturn _class_createInstanceFromZone(cls, 0, nil,OBJECT_CONSTRUCT_CALL_BADALLOC);
}

• 内部调用_class_createInstanceFromZone方法

4. _class_createInstanceFromZone方法

static ALWAYS_INLINE id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,int construct_flags = OBJECT_CONSTRUCT_NONE,bool cxxConstruct = true,size_t *outAllocatedSize = nil)
{ASSERT(cls->isRealized());// Read class's info bits all at once for performancebool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();bool hasCxxDtor = cls->hasCxxDtor();bool fast = cls->canAllocNonpointer();size_t size;// 1. 计算需要初始化的大小size = cls->instanceSize(extraBytes);if (outAllocatedSize) *outAllocatedSize = size;// 2. 开辟对应大小的内存空间id obj;if (zone) {obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);} else {obj = (id)calloc(1, size);}if (slowpath(!obj)) {if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {return _objc_callBadAllocHandler(cls);}return nil;}// 3. 把开辟的内存和类关联起来if (!zone && fast) {obj->initInstanceIsa(cls, hasCxxDtor);} else {// Use raw pointer isa on the assumption that they might be// doing something weird with the zone or RR.obj->initIsa(cls);}if (fastpath(!hasCxxCtor)) {return obj;}construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;return object_cxxConstructFromClass(obj, cls, construct_flags);
}

• 这个方法是最重要的方法，从实现中可以得知，它主要干了三件事：

  1. cls->instanceSize(extraBytes);：计算内存大小
  2. (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);或者(id)calloc(1, size)：开辟内存，返回地址指针
  3. obj->initInstanceIsa(cls, hasCxxDtor);或者obj->initIsa(cls);：把内存和类关联起来

instanceSize：计算内存大小

inline size_t instanceSize(size_t extraBytes) const {// 是否通过缓存，快速计算大小if (fastpath(cache.hasFastInstanceSize(extraBytes))) {return cache.fastInstanceSize(extraBytes);}// 没有缓存，计算大小size_t size = alignedInstanceSize() + extraBytes;// CF requires all objects be at least 16 bytes.if (size < 16) size = 16;  return size;
}

• 进入后首先判断缓存中是否允许快速计算大小

fastInstanceSize

• 如果缓存存在，则通过缓存去计算大小，进入fastInstanceSize方法

size_t fastInstanceSize(size_t extra) const
{ASSERT(hasFastInstanceSize(extra));if (__builtin_constant_p(extra) && extra == 0) {return _flags & FAST_CACHE_ALLOC_MASK16;} else {size_t size = _flags & FAST_CACHE_ALLOC_MASK;// remove the FAST_CACHE_ALLOC_DELTA16 that was added// by setFastInstanceSize// 删除由setFastInstanceSize添加的FAST_CACHE_ALLOC_DELTA16 8个字节// 进行16字节对齐return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);}
}

• 这里的size是通过_flags & FAST_CACHE_ALLOC_MASK计算得到的。这里需要我们了解类的具体结构，这里可以简单理解为一个类中成员变量的大小
• 通过16字节，进行内存对齐。如果这里不了解内存对齐知识，请看内存对齐

static inline size_t align16(size_t x) {return (x + size_t(15)) & ~size_t(15);
}

• 该方法的作用就是16字节对齐，对一个数以16倍数进行向上取整

alignedInstanceSize

• 如果没有缓存，则进入alignedInstanceSize方法

// Class's ivar size rounded up to a pointer-size boundary.
uint32_t alignedInstanceSize() const {return word_align(unalignedInstanceSize());
}

1. 我们需要获取未内存对齐大小unalignedInstanceSize()

// May be unaligned depending on class's ivars.
// 可以根据类的成员变量进行对齐。
uint32_t unalignedInstanceSize() const {ASSERT(isRealized());return data()->ro()->instanceSize;
}

• 该方法内部是获取类的成员变量大小

2. 对获取到的内存大小，进行对齐

#define WORD_MASK 7UL
static inline uint32_t word_align(uint32_t x) {return (x + WORD_MASK) & ~WORD_MASK;
}

• 此处采用的是8字节对齐，也就是说对象中成员变量按照8字节对齐。

malloc/calloc：开辟内存

• 通过调用可知void *zone传入的是0，所有这里会调用calloc方法

• 首先通过instanceSize计算出内存大小，然后向系统申请对应大小，返回给obj

• calloc具体底层实现，可阅读iOS中calloc和malloc源码分析

initInstanceIsa/initIsa：内存和类关联

• 通过调用可知void *zone传入的是0，并且现在是支持Nonpointer类型isa，所以会调用initInstanceIsa方法

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

• 内部调用了initIsa方法，具体流程，我们会在isa这一章节讲解。可参考Runtime源码剖析-对象初始化isa章节。

• 在初始化后，我们打印obj对象，发现po出了它对应的类型。说明initInstanceIsa方法，把内存和类关联起来。

总结

• alloc核心方法是_class_createInstanceFromZone
• alloc 的核心作用就是开辟内存，通过isa指针与类进行关联

init

• 在开发过程中，我们通常把alloc和init放在一起使用。[[NSObject alloc] init]
• 那具体init做了些什么操作。

- (id)init {return _objc_rootInit(self);
}id
_objc_rootInit(id obj)
{// In practice, it will be hard to rely on this function.// Many classes do not properly chain -init calls.return obj;
}

• 在源码中是直接返回了obj对象本身
• init方法更多的是提供给我们一个抽象接口，可以让我们在子类中重写它，达到自定义效果。

new

• 我们开发中，会发现有时候会直接调用new，而不是alloc init。

+ (id)new {return [callAlloc(self, false/*checkNil*/) init];
}

• 直接调用了callAlloc函数，并且调用init函数。所以可以得出new等价[alloc init]
• 一般不建议使用new。原因是有时候会重写init方法，类似于initWithXXX。使用new方法，无法调用到自定义的初始化方法