Person * p1 = [Person alloc];
    Person * p2 = [p1 init];
    Person * p3 = [p1 init];
    
    NSLog(@"对象%@ - 指针指向的地址%p - 指针地址%p",p1,p1,&p1);
    NSLog(@"对象%@ - 指针指向的地址%p - 指针地址%p",p2,p2,&p2);
    NSLog(@"对象%@ - 指针指向的地址%p - 指针地址%p",p3,p3,&p3);

打印结果

2021-03-24 13:41:24.665807+0800 111[606:63324] 对象<Person: 0x28291c080> - 指针指向的地址0x28291c080 - 指针地址0x16f91d178
2021-03-24 13:41:24.666031+0800 111[606:63324] 对象<Person: 0x28291c080> - 指针指向的地址0x28291c080 - 指针地址0x16f91d170
2021-03-24 13:41:24.666153+0800 111[606:63324] 对象<Person: 0x28291c080> - 指针指向的地址0x28291c080 - 指针地址0x16f91d168

三个对象的内存地址都指向了同一个 0x28291c080，但使用了3个内存指针指向了这个相同的内存地址。
（猜 因为三个对象 有三个isa指针？）

先下载oc的源码，在该库的readme中，作者也探索了alloc的流程，也做了对应的分析和标注。

在源码中 master / objc_debug-master / objc-781 / objc.xcodeproj项目，双击运行
打开项目后，在Public Headers可以看到NSObject.h系统类NSObject的头文件的所有属性，对象方法，类方法。

头文件.jpg

找到alloc方法后，先选中alloc，然后按住Command键，再右键即可跳转（跟踪）到NSObject.mm文件，文件在/Source中可以找到。

alloc方法

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

可以看到方法中调用了_objc_rootAlloc函数，并传入了self自己本身

再跟到_objc_rootAlloc函数可以看到

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

注释中写到基本点的类实现通过 类方法（+）调用 alloc，并且cls(类)不能为nil

在代码里又调用了 callAlloc方法
参数分别为：
1.cls 类
2.是否检查为nil，默认为false
3.是否allocWithZone 传入的是true

再跟进到callAlloc函数里

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

注释中写到通过[类 alloc] 或者[类 allocWithZone:nil]方法来调用得到,接着是简化优化
OBJC2 是判断oc 2.0可用
其中用到了两个宏,宏写在了项目的/Project Headers/objc-os.h中 line.151、152

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

具体的解释可以参考这篇__builtin_expect 说明
__builtin_expect(bool(x), 1)的意思是x的值为真的可能性最大，编译器会更大的可能编译 if(__builtin_expect(bool(x), 1))里的代码。
相反__builtin_expect(bool(x), 0)的意思是x的值为假的可能性最大，编译器会最大的可能性不走判断该方法的代码，会走else里方法。
所以

//最大可能性为真  编译器最大可能走这个判断
#define fastpath(x) (__builtin_expect(bool(x), 1)) 
//最大可能性为假，编译器最大的可能不走这个判断，会走else
#define slowpath(x) (__builtin_expect(bool(x), 0))

借用__builtin_expect 说明的举例

int x, y;
 if(slowpath(x > 0))
    y = 1; 
else 
    y = -1;

代码里，编译器会优先执行y = -1，因为判断里的最大可能性为假，直接走else。
通过这种方式，编译器在编译过程中，会将可能性更大的代码紧跟着执行代码，从而减少指令跳转带来的性能上的下降。

回头看代码

截图.png

等等！~
_objc_rootAllocWithZone是不是有点眼熟？

截图.png

再跟到_objc_rootAllocWithZone

_objc_rootAllocWithZone

id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused)
{
    // allocWithZone under __OBJC2__ ignores the zone parameter
    //allocWithZone 在 oc 2.0之后忽略zone的参数
    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:需要开辟的内存大小，可以看到外部传入的extraBytes为0
    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: 关联到相应的类
    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.计算出需要开辟的内存空间大小
2.根据需要开辟的内存大小向系统申请内存，返回地址指针
3.创建类的isa 与 地址指针绑定

1.计算内存大小

instanceSize

计算需要开辟的内存空间大小是通过 size = cls->instanceSize(extraBytes);内部实现如下

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

在最后的时候，判断了 size是否小于16，如果是则 size = 16的操作。
在判断代码里cache.hasFastInstanceSize(extraBytes)是判断cache里是否有实例的内存大小，传入的是extraBytes 值是0。前面是fastpath最大可能性为真（前面说过）。
接着通过cache.fastInstanceSize(extraBytes)来计算最终的实例大小。

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

代码中_flags & FAST_CACHE_ALLOC_MASK16可以通过位与运算快速提取舍入到下一个16字节边界的实例大小 得到计算后的size
接着将size 加上开辟的内存大小extra 减去 FAST_CACHE_ALLOC_DELTA16（值为0x0008）。理解为实例大小加上内存大小，在进行8位的偏移。
在代码的最后，返回了align16方法的返回值，字面意思就是16对齐

align16

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

代码中可以看到 (x + size_t(15)) & ~size_t(15)，说实话我一开始是没懂！也是翻了教程来学，好多种解释。
引用了一个博主的解释

16字节对齐运算

15
二进制为0000 0000 0000 1111

接着将15的二进制取反 （~）取反操作
15取反
二进制为1111 1111 1111 0000

之后将23的二进制与 取反后的二进制进行 与 运算 相同为1 不同为0
与后二进制为 0000 0000 0001 0000 值为16，非常巧妙的计算！

16对齐的目的

• 提高性能，加快存取速度 通常内存是由一个个字节组成的，cpu在存取数据时，并不是以字节为单位存储，而是以块为单位存取。频繁存取字节未对齐的数据，会极大降低cpu的性能。固定16字节的存取长度，可以更快存取数据。
• 更安全 苹果如今采用16字节对齐，由于在一个对象中，isa占8字节，而对象每个属性也占8字节，当对象无属性时，会预留8字节，即16字节对齐，如果不预留，CPU存取时以16字节长度会导致访问到相邻的其他对象，造成访问混乱。

回过头来看 size = cls->instanceSize(extraBytes)，此时size的内存大小就为16，哪怕Int类型为4个字节，那也会开辟出16大小的内存(8个字节)。如果一个类里只有两个int类型的属性，那么这两个int类型的属性会共用一个16大小的内存

isa

isa本身的结构体内部只有一个指针，且isa指针占用内存8个字节。

@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
    Class isa  OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}

可以用runtime的class_getInstanceSize来获取实例大小

打印isa大小及内存大小

现在给Person加三个字段，一个Int,一个NSString,一个Int。顺序很重要！

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface Person : NSObject
@property(nonatomic,assign) NSInteger age;
@property(nonatomic,strong) NSString * name;
@property(nonatomic,assign) NSInteger height;
@end

内存占用说明.png

申请内存，返回地址指针

由于在调用_class_createInstanceFromZone时，第三个参数传入的是nil，接收的是zone，而iOS8 以后废弃了用zone来开辟内存的方式，所以直接调用了 obj = (id)calloc(1, size)方法来申请内存。

NEVER_INLINE
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(Class cls, size_t extraBytes, void *zone,
                              int construct_flags = OBJECT_CONSTRUCT_NONE,
                              bool cxxConstruct = true,
                              size_t *outAllocatedSize = nil)
{
。。。。。。。。
。。。。。。。。
    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);
    }

此时打印obj ,po obj出来的只有 ）0x开头的地址，并不是<Person 0xxxxxxxxx>这类的信息，因为还没有将类与该类的内存地址进行关联。
calloc只是将拿到的内存大小size去申请内存空间。

关联相应的类

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

//initInstanceIsa的实现
inline void 
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
    ASSERT(!cls->instancesRequireRawIsa());
    ASSERT(hasCxxDtor == cls->hasCxxDtor());

    initIsa(cls, true, hasCxxDtor);
}

代码中将类 和 hasCxxDtor传入initInstanceIsa方法，在initInstanceIsa方法中调用了initIsa方法也传入了cls类.
这些操作后就将类 与 类的内存地址*相关联起来了。

(lldb) po p1
<Person: 0x60000048b740>

此时类的alloc结束！
总结alloc的作用1.计算类大小，进行16字节对齐。2.拿到类大小去申请开辟内存。3.将类与内存进行关联
引用 K哥的贼船图alloc流程图

流程图

init

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

• 代码里有两个init方法，一个是类方法，一个是对象方法，都是反悔了对象本身。
• 类方法返回的是一个id任意类型的self，是为了给开发者自定义构造方法的入口，如重写类方法来设计工厂模式

FruitFactory.h

#import <Foundation/Foundation.h>
#import "FruitProtocol.h"

NS_ASSUME_NONNULL_BEGIN

typedef NS_ENUM(NSInteger,FruitType){
    FruitTypeApple,
    FruitTypeOrange,
};

@interface FruitFactory : NSObject

+(id<FruitProtocol>)initWithType:(FruitType)type;

@end

NS_ASSUME_NONNULL_END   

FruitFactory.m

#import "FruitFactory.h"
#import "AppleFruit.h"
#import "OrangeFruit.h"

@implementation FruitFactory

+(id<FruitProtocol>)initWithType:(FruitType)type{
    id<FruitProtocol> factory = nil;
    switch (type) {
        case FruitTypeApple:
            factory = [[AppleFruit alloc] init];
            break;
        case FruitTypeOrange:
            factory = [[OrangeFruit alloc] init];
            break;
            
        default:
            break;
    }
    
    return factory;
}

@end

调用工厂方法时就是init开头，但返回的可能是不同的类。所以要拿id来接收

#import "ViewController.h"
#import "FruitFactory.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    id<FruitProtocol> factory1 = [FruitFactory initWithType:FruitTypeApple];
    factory1.name = @"苹果";
    [factory1 createProduct];
    
    
    id<FruitProtocol> factory2 = [FruitFactory initWithType:FruitTypeOrange];
    factory2.name = @"橘子";
    [factory2 createProduct];
    
}

@end

new

尝尝用new的机会并不多，但new的源码与alloc + init的本质无区别。

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

new操作无法对工厂设计重载init方法时做的业务操作进行执行。如果不需要重载自己写的方法时，则不需要考虑。
如:

self.tableView.tableFooterView = [UIView new];