iOS 探索alloc和init以及new

我们平常开发中，我们在创建对象时，一般都是用这样：

LPPerson *obj1 = [[LPPerson alloc]init];
LPPerson *obj2 = [LPPerson new];

那大家有想过，为什么必须要这样创建才行？alloc和init以及new到底干了什么？今天我们就来探索下

一、准备工作

1、源码准备

• 为了保证我们顺利学习，请先准备一份最新的Objc源码
• 配置下，保证其可以正常编译。具体流程可以百度，很多。

2 、编译源码方式

• 添加符号断点（symbol BreakPoint）

点击添加断点并选择如下：

image.png

然后添加对应的断点内容：

image.png

• 按压Control并点击Setp in

step in.gif

• 使用汇编源码

在Xcode上方的Debug菜单栏中点击如下选项：

image.png

然后就会出现如下汇编界面：

image.png

二、探索alloc

我新建了一个LPPerson类，并在Viewcontroller中进行了创建工作，具体代码如下：

- (void)viewDidLoad {
    [super viewDidLoad];
    
    LPPerson *person = [LPPerson alloc];
    LPPerson *person1 = [person init];
    LPPerson *person2 = [person init];
    
    NSLog(@"%@--%p--%p",person,person,&person);
    NSLog(@"%@--%p--%p",person1,person1,&person1);
    NSLog(@"%@--%p--%p",person2,person2,&person2);
    
}

我们看下运行结果：

<LPPerson: 0x600001844b60>--0x600001844b60--0x7ffee5f8c168
<LPPerson: 0x600001844b60>--0x600001844b60--0x7ffee5f8c160
<LPPerson: 0x600001844b60>--0x600001844b60--0x7ffee5f8c158

从上面的结果我们可以得到一个信息：

上面三个对象的内存空间是同一个，所以其内容和指针地址是相同的，但是其对象的内存地址是不一样的

那是不是我们可以得到结论---alloc实际上就是为对象分配内存空间的呢？

接下来我们结合源码来验证下：

• 在源码中搜索alloc {

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

• 再进入_objc_rootAlloc:

// Base class implementation of +alloc. cls is not nil.
// Calls [cls allocWithZone:nil].
id
_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

• 再进入callAlloc：

// Call [cls alloc] or [cls allocWithZone:nil], with appropriate 
// shortcutting optimizations.
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

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

这里就发现代码不是很简单了，根据断点我们知道接下里会走_objc_rootAllocWithZone

slowpath & fastpath

这两个宏，在源码中定义如下：

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

其中的__builtin_expect指令是由gcc引入的，
1、目的：编译器可以对代码进行优化，以减少指令跳转带来的性能下降。即性能优化
2、作用：允许程序员将最有可能执行的分支告诉编译器。
3、指令的写法为：__builtin_expect(EXP, N)。表示 EXP==N的概率很大。
4、fastpath定义中__builtin_expect((x),1)表示 x 的值为真的可能性更大；即 执行if 里面语句的机会更大
5、slowpath定义中的__builtin_expect((x),0)表示 x 的值为假的可能性更大。即执行 else 里面语句的机会更大

cls->ISA()->hasCustomAWZ()

其中fastpath中的 cls->ISA()->hasCustomAWZ()表示判断一个类是否有自定义的 +allocWithZone实现，这里通过断点调试，是没有自定义的实现，所以会执行到 if 里面的代码，即走到_objc_rootAllocWithZone

• 进入_objc_rootAllocWithZone

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

• 进入_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;
    // 1:要开辟多少内存
    size = cls->instanceSize(extraBytes);
    if (outAllocatedSize) *outAllocatedSize = size;

    id obj;
    if (zone) {
        obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
    } else {
        // 2;怎么去申请内存
        obj = (id)calloc(1, size);
    }
    if (slowpath(!obj)) {
        if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
            return _objc_callBadAllocHandler(cls);
        }
        return nil;
    }

    // 3: 将 cls类 与 obj指针（即isa） 关联
    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);
}

if (zone) {
       obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
}

zone这种方式已经被废弃了，所以会直接走calloc函数

_class_createInstanceFromZone这部分是alloc源码的核心操作，我们可以看到，其中非常关键的三个步骤：

• cls->instanceSize：计算开辟内存空间

• calloc：申请内存

• obj->initInstanceIsa：将 cls类 与 obj指针（即isa） 关联

1.instanceSize：计算开辟内存空间

进入instanceSize中，

 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:

 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
            return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
        }
    }

进入align16内存对齐关键算法：

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

1.这里为什么要进行内存对齐呢？
CPU 并不是以字节为单位存取数据的。CPU把内存当成是一块一块的，块的大小可以是2，4，8，16字节大小，因此CPU在读取内存时是一块一块进行读取的。每次内存存取都会产生一个固定的开销，减少内存存取次数将提升程序的性能。即我们常说的空间换时间。所以 CPU 一般会以 2/4/8/16/32 字节为单位来进行存取操作。我们将上述这些存取单位也就是块大小称为（memory access granularity）内存存取粒度。

2.那为什么要使用16字节对齐？
在一个对象中，至少包含一个isa指针，isa指针就会占据8字节的空间，除了isa，对象可能会有其他的属性，如果没有其它属性，就会预留8字节的空间，如果有其它属性会继续增加，但是大小永远是16的倍数。

3.对齐算法解析：

image.png

2. calloc申请内存，返回地址指针

通过instanceSize计算的内存大小，向内存中申请 大小 为 size的内存，并赋值给obj，因此 obj是指向内存地址的指针。

obj = (id)calloc(1, size);

在calloc执行之前，obj为nil，但是calloc执行后，obj就为非nil了

image.png

3.obj->initInstanceIsa：类与isa关联

在执行完initInstanceIsa后，就可以得出一个对象指针了

• 通过对alloc源码的分析，可以得知alloc的主要目的就是开辟内存，而且开辟的内存需要使用16字节对齐算法，现在开辟的内存的大小基本上都是16的整数倍
• 开辟内存的核心步骤有3步：计算大小-- 申请内存 -- 关联class

alloc具体流程如下：

image.png

三、探索init

init的流程就相对简单很多，查看objc源码可知主要分为类方法和实例方法：

• 类方法

+ (id)init {
    return (id)self;
}

• 实例方法

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

四、探索new

同样的，查看源码:

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

可以看到，new和alloc init本质上没有区别，new = [alloc init].但是在我们的开发中，如果一个类，你重写了init构法，就不要使用new来创建了，new可能并不会执行你重新的方法。

觉得不错记得点赞哦！听说看完点赞的人逢考必过，逢奖必中。ღ( ´･ᴗ･` )比心