源码定位
在业务层开发时，很少会研究Objc源码及底层实现。
下面罗列查找源码的3个方法：
1. 通过符号断点跟流程。
2. ctrl + step into；结合符号断点查到源码库。
3. 运行时汇编跟流程。汇编开启方法：Xcode->Debug->Debug workflow->Always Show Disassembly）
举🌰：
在测试项目新建一个继承NSObject的类，并alloc出一个实例对象：
FLObject *object = [FLObject alloc];
打好断点后运行，并开启汇编调试
如图symbol，我们可以看到下一条指令的汇编注释symbol stub for: objc_alloc得知立即调用存根符号为objc_alloc的函数，所以我们不妨增加一个objc_alloc的符号断点，接着运行可以看到
所以可以看到在调用 FLObject *object = [FLObject alloc]; 时，底层调用为libobjc.A.dylib动态链接库中的objc_alloc方法。
通过苹果开源库下载相关开源库。
注：callq：属于x86的指令，即调用函数时的压栈出栈。图libObjc中callq指令会使程序跳到0x10934b30的地址中执行。除此之外，该指令还会将当前函数的下一条指令入栈
2.alloc&init 探索
alloc 流程分析
alloc 的实现流程如下：
- 自定义类调用的
alloc，点击进入定义：
/// alloc分析 step1
+ (id)alloc {
return _objc_rootAlloc(self);
}
- 跳转至
rootAlloc内部实现
/// alloc分析 step2
id
_objc_rootAlloc(Class cls)
{
return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}
- 跳转至
callAlloc内部实现
static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false) /// alloc分析 step3
{
#if __OBJC2__
if (slowpath(checkNil && !cls)) return nil;
/// 判断当前类是否重写allocWithZone方法
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内部实现中，有 slowpath和fastpath用于判断的宏。
/// x很大可能为真，即真值判断
#define fastpath(x) (__builtin_expect(bool(x), 1))
/// x很大可能为假，即假值判断
#define slowpath(x) (__builtin_expect(bool(x), 0))
其中__builtin_expect是由gcc引入的
目的：编译器可以对代码进行优化，以减少指令跳转带来的性能下降，即性能优化
作用：允许程序员将最有可能执行的分支告诉编译器。
写法： __builtin_expect(EXP, N)。表示 EXP==N的概率很大。
hasCustomAWZ
fastpath中cls->ISA()->hasCustomAWZ()表示 当前类是否重写类的allWithZone，此时判断成立，继续调用_objc_rootAllocWithZone。
- 跳转
_objc_rootAllocWithZone实现
id
_objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused) /// alloc分析 step4
{
// allocWithZone under __OBJC2__ ignores the zone parameter
return _class_createInstanceFromZone(cls, 0, nil,
OBJECT_CONSTRUCT_CALL_BADALLOC);
}
-
跳转
_class_createInstanceFromZone,此方法是alloc源码的核心操作。其中主要实现分为3部分：- cls->instanceSize：计算需要开辟的内存大小；
- calloc(1, 计算的内存大小)：申请内存，并返回地址指针；
- obj->InitInstanceIsa：关联 cls 与 地址指针
static ALWAYS_INLINE id /// alloc分析 step5
_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 {
/// alloc 开辟内存的地方
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);
}
核心操作细分
1. cls->instanceSize：计算所需开辟的内存大小
源码实现
/// alloc分析 instanceSize step1
size_t instanceSize(size_t extraBytes) const {
/// 经断点调试，fastpath真值判断成立，编译器快速计算内存大小
if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
return cache.fastInstanceSize(extraBytes);
}
/// 计算类中所有属性的大小 + 额外的字节数0
size_t size = alignedInstanceSize() + extraBytes;
// CF requires all objects be at least 16 bytes.
if (size < 16) size = 16;
return size;
}
/// alloc分析 instanceSize step2
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
/// 16字节对齐算法
return align16(size + extra - FAST_CACHE_ALLOC_DELTA16);
}
}
align16(size_t x) 即16字节对齐算法。系统开辟内存时，默认以16字节对齐，对象实际所需内存按8字节对齐，16字节对齐也为后期扩容做准备。
下面是align16()内部实现：
/*
0000 0000 0000 1111 15
0000 0000 0001 0111 23 1.入参size + 15
1111 1111 1111 0000 15的取反 2.对15取反
0000 0000 0001 0000 16倍数 3.step1与step2 取&，即低位抹零，留下16的倍数
**/
static inline size_t align16(size_t x) {
return (x + size_t(15)) & ~size_t(15);
}
2. calloc：申请内存，返回指向该内存的指针
通过instanceSize计算的内存大小，向内存中申请 大小 为 size的内存，并赋值给obj，因此 obj是指向内存地址的指针
obj = (id)calloc(1, size);
验证：在未执行calloc时，po obj为nil，执行后calloc后再po，返回了一个地址指针。
3. obj->InitInstanceIsa：关联 当前类 与 地址指针
经过第二步，内存已申请，并且也拿到了当前类；下面就是将 类 与 地址指针 即进行关联，内部实现流程如下:
即：初始化isa指针，将isa指针指向申请的内存地址，在将指针与cls类进行 关联。
总结
alloc的核心工作就是开辟内存，并使用16字节对齐算法。而开辟的系统开辟的内存大小都是16的倍数。
主要步骤：计算大小 -> 开辟内存 -> 关联
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;
}
new 源码探索
关于new方法，我们在开发中多使用alloc + init的方法创建并初始化对象。其两者本身并无区别，从源码可以得知：new方法通过调用callAlloc & init方法，等价于[[cls alloc] init]。
+ (id)new {
return [callAlloc(self, false/*checkNil*/) init];
}
但是在开发中，new的应用场景并不多。 因为我们可以通过重写init来自定义初始化操作，同时会在这个方法中调用[super init]，而用new初始化可能会无法走到自定义的init的实现。
举例：
在自定义类中添加两个初始化方法，重写 父类init 及 自定义初始化构造方法，下面我们分别执行new 及 自定义初始化方法
-
执行new
new 方法 -
执行 自定义初始化
构造初始化
总结
- 子类没有重写父类的init，new调用父类的init；
- 子类重写父类init，new会调用子类重写init；
- 使用
alloc + init，可以在init添加子类所需参数，拓展性更高。
