alloc&init底层重识
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
在fastpath中 cls->ISA()->hasCustomAWZ())判断一个类是否有自定义的+allocWithZone实现，AWZ就是AllocWithZone的缩写。所以fastpath(!cls->ISA()->hasCustomAWZ())表示的是这个类没有自定义的+allocWithZone时，走if里的代码。
代码中又接着调用了 _objc_rootAllocWithZone，传入cls(类)，和一个nil （接收参数为 malloc_zone_t zone __unused）
等等！~
_objc_rootAllocWithZone是不是有点眼熟？
截图.png
在alloc下方，allocWithZone方法中直接调用了_objc_rootAllocWithZone，这个等重学allocWithZone的时候再细究
再跟到_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字节对齐运算
其中X为计算出的实例大小 比如为8，size_t(15)为什么是15？写死？
x +15 = 23,
二进制为 0000 0000 0001 0111
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的类isa大小只有8 但是系统给开辟的空间却有16
现在给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
图中可看出，苹果的确是做了16字节对齐的操作，Int本该4个字节却开辟了8个字节的空间。
申请内存，返回地址指针
由于在调用_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];
