前言

作为开发iOS的一名程序员，平时用到最多的肯定是alloc这个方法，那么allo底层到底做了什么呢？ 首先我们写一段测试代码如下：

  SPPerson *p1 = [SPPerson alloc];
  SPPerson *p2 = [p1 init];
  SPPerson *p3 = [p1 init];
  SPPerson *p4 = [SPPerson alloc];
    
  NSLog(@"%@-%p-%p",p1,p1,&p1);
  NSLog(@"%@-%p-%p",p2,p2,&p2);
  NSLog(@"%@-%p-%p",p3,p3,&p3);
  NSLog(@"%@-%p-%p",p4,p4,&p4);

控制台输出结果如下：

  <SPPerson: 0x600000050410>-0x600000050410-0x7ffee943e098
  <SPPerson: 0x600000050410>-0x600000050410-0x7ffee943e090
  <SPPerson: 0x600000050410>-0x600000050410-0x7ffee943e088
  <SPPerson: 0x600000050420>-0x600000050420-0x7ffee943e080

分析输出结果我们发现：

• 1. p1 p2 p3的内容，指向的对象的地址都是一样的，但是指针的地址不一样
• 2. p4和p1 p2 p3的内容，指向的对象的地址，指针的地址都不一样 我们得到结论：

alloc具有开辟一块内存功能，而init没有开辟内存的功能。 栈区开辟的内存是高地址到低地址，堆区则是低地址到高地址。 看来分配内存还是在alloc这，那么alloc到底是怎么分配内存的呢？ 我们点进去alloc，来到了：

+ (instancetype)alloc OBJC_SWIFT_UNAVAILABLE("use object initializers instead");

然后发现点不进去了，看来需要找别的方法了

底层探索的三种基本方法

第一种：符号断点:

控制台按住control+step into看到了objc_alloc然后给objc_alloc加上符号断点即可

第二种：汇编调试:

Xcode -> Debug -> Debug Workflow -> Always Show Disassembly

第二种：符号断点，判断位置:

直接加符号断点alloc，注意就是先取消断点执行到具体代码的时候加上符号断点

通过以上三种方法分析我们发现alloc实际是调用了

libobjc.A.dylib`objc_alloc

于是我们下载源码，解决编译问题后开始分析源码

源码分析

我么搜索alloc {来到了

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

点进_objc_rootAlloc：

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

点进callAlloc：

callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
    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));
}

callAlloc首先是一个宏__OBJC2__它的定义是：

// Define __OBJC2__ for the benefit of our asm files.
#ifndef __OBJC2__
#   if TARGET_OS_OSX  &&  !TARGET_OS_IOSMAC  &&  __i386__
        // old ABI
#   else
#       define __OBJC2__ 1
#   endif
#endif

这个定义是在objc4-787.1, 但是在objc4-818.2中没有了，推测是编译器自动加上了这个宏 然后是fastpath和slowpath，点击去看

#define fastpath(x) (__builtin_expect(bool(x), 1))
#define slowpath(x) (__builtin_expect(bool(x), 0))

表示的意思是fastpath(x):x大概率为真，slowpath(x):x大概率为假 然后通过断点我们来到_objc_rootAllocWithZone，点进去:

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

点进去_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 performance
    bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
    bool hasCxxDtor = cls->hasCxxDtor();
    bool fast = cls->canAllocNonpointer();
    size_t size;

    size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

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

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

我的天，这么大段代码要怎么分析呀？ 不要急我们重点看返回值，返回obj，然后看obj赋值做了什么，分析等到核心的三步：

• 1.instanceSize，计算分配对象都需空间
• 2.calloc，分配空间
• 3.initIsa，把对象关联到isa指针上 第一步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;
    }

看到不足16个字节返回16，然后是alignedInstanceSize和extraBytes，通过注释extraBytes实际是depending on class's ivars.是类的成员变量决定的，然后alignedInstanceSize是字节对齐，点进去：

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

• (x + 7) & ~7等价于 (x + 7) >> 3 << 3
• (x + 15) & ~15等价于 (x + 7) >> 4 << 4

流程图