alloc流程分析一

1. 初始化创建三个变量，分别添加打印信息。代码如下：

NSObject* obj1 = [NSObject alloc];
NSObject* obj2 = [obj1 init];
NSObject* obj3 = [obj1 init];
NSLog(@"%@--%p---%p",obj1,obj1,&obj1);
NSLog(@"%@--%p---%p",obj2,obj2,&obj2);
NSLog(@"%@--%p---%p",obj3,obj3,&obj3);

• 通过打印信息发现，前面两个元素%@，%p 打印信息完全一致。第三个&obj是不一致的。
• 因为%@ 实际上就是调用description方法，内部调用添加类信息+%p的指针地址打印。所以对同一个对象 %@ %p 打印的地址是相同的。
• alloc开辟内存空间，然后init实际上什么都没做。所以打印信息obj1 -- obj3都是相同的，因为是同一个地址。
• &obj1、&obj2、&obj3地址不同，因为是不同变量的地址。然后因为栈内内存是连续的，在没有属性的情况下，&obj1、&obj2、&obj3相差8个字节。

2. 查找源码库方法：

• 打一个符号断点，symbolic breakPoint 标记alloc. 运行后发现有很多个运行断点数据。先将断点去掉，然后单步断点到上面的alloc方法，查看。再打开符号断点。运行，能看到如下结果。 其中libobjc.A.dylib 就是对应的库。

libobjc.A.dylib`+[NSObject alloc]:
 ->  0x10a7e05ed <+0>: jmp    0x10a7e0611 ; _objc_rootAlloc

• 先去掉符号断点，单步断点到alloc，运行到后，按住control键，点击step into。出现objc_alloc，添加符号断点objc_alloc，就能看到libobjc.A.dylib 对应的库。

• 汇编查看流程：单步断点，执行到断点后，Debug->Debug workFlow -->Always show Disassembly，再次断点到 callq，执行到后，出现symbol stub for: objc_alloc，使用objc_alloc 添加符号断点，出现libobjc.A.dylib对应的库。

3. init

• NSObject内部实际上只调用了return (id)self用来重写.并没做其他任何事情。
• init存在是为了方便使用工厂设计模式，提供构造方法。
• new方法：实际上调用了return [callAlloc(self,false) init];实际上就只调用了alloc init。 不过不会调用重写的init 工厂方法。 所以并不建议直接使用new。

4. alloc底层代码流程：

• 下载源码地址https://opensource.apple.com/release/macos-113.html，搜索objc4/,下载824源码。

• 在源码中搜索alloc {,可以直接定位到alloc 方法定义。

• 查看源码，可以知道alloc 内部代码调用层级如下：

  
  
  alloc流程图.png

• 从流程图片中，可以看出，内部主要调用三个方法。

  • instanceSize计算出变量所需内存大小。
  • calloc/malloc_zone_batch_malloc向系统申请开辟内存，返回地址指针。
  • initInsa/initInstanceIsa关联到相应的类。

• alloc流程源代码如下：

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

static ALWAYS_INLINE id
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
    if (allocWithZone) {
        return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
    }
    return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
}

+ (id)allocWithZone:(struct _NSZone *)zone {
    return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
}

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

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());
    bool 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 {
        obj->initIsa(cls);
    }

    if (fastpath(!hasCxxCtor)) {
        return obj;
    }
    construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;
    return object_cxxConstructFromClass(obj, cls, construct_flags);
}

5.instanceSize计算出变量所需内存大小具体流程如下：

• instanceSize用于计算对象所占内存空间大小。通过计算中的align16函数可以看出系统分配对象内存时，内部有使用16字节对齐方式。
• 之所以采用16字节对齐，是因为isa指针8个字节，为了保证内存安全，预留8个字节。所以是16字节对其。16字节更加安全，不会读取到其他值。为甚需要内存对其。
• 读取方式： 整数读取，方便快捷，每次读取8个字节，不需要更改每次读取长度。所以是8的整数倍字节对其。这里有问题需要修改.
• 16字节对其计算方式如下：
  (x + size_t(15)) & ~size_t(15);, 原有字节+15，与15的二进制取反后，取与。计算出结果。

• 具体流程图：

  
  
  instanceSize大小计算.png
• 源码如下：

size_t instanceSize(size_t extraBytes) const {
        if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
            return cache.fastInstanceSize(extraBytes);
        }
        size_t size = alignedInstanceSize() + extraBytes;//extraBytes 默认传递0
        if (size < 16) size = 16;
        return size;
}
//流程一  
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;
            return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
        }
}
    
//计算字节
static inline size_t align16(size_t x) {
    return (x + size_t(15)) & ~size_t(15);
}

//流程二
uint32_t alignedInstanceSize() const {
        return word_align(unalignedInstanceSize());
}

uint32_t unalignedInstanceSize() const {
        ASSERT(isRealized());
        return data()->ro()->instanceSize;//获取class_ro_t 结构体中instanceSize变量的值
}

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