1、alloc init
首先用alloc生成一个LGPerson对象。在init另外的对象。
- (void)viewDidLoad {
[super viewDidLoad];
LGPerson *p1 = [LGPerson alloc];
LGPerson *p2 = [p1 init];
LGPerson *p3 = [p2 init];
NSLog(@"%@ - %p - %p",p1,p1,&p1);
NSLog(@"%@ - %p - %p",p2,p2,&p2);
NSLog(@"%@ - %p - %p",p3,p3,&p3);
}
输出生成的对象信息。
对象信息
从输出的对象信息来看。三个对象的指针地址不同。但是指向的却是同一块内存。
LGPerson对象alloc已经开辟内存、对象已经生成。init没有对已经生成的内存进行任何处理。
截屏2020-09-06 15.19.15.png
查找动态链接库
- 符号断点
为alloc方法添加符号断点。
注意：alloc方法调用较多。先定位到对象的alloc，在开启alloc的符号断点。
截屏2020-09-06 15.32.00.png
42BE4DEE-A234-4B04-BF5D-39407E81A407.png
-
control + step into
control + step into
添加符号断点 -
汇编查看
打开汇编
打开汇编定位到需要的对象，进入汇编会发现objc_alloc。将断点到汇编的objc_alloc地方。接下来重复control + step into的操作。
objc_alloc
2、alloc 开辟内存探索
动态库源码搜索需要的objc库。
2.1 alloc源码探索
根据LGPerson的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__
/** slowpath fastpath
* 其作用是将最有可能执行的分支告诉编译器
* x很可能为真， fastpath 可以简称为 真值判断
* #define fastpath(x) (__builtin_expect(bool(x), 1))
* x很可能为假，slowpath 可以简称为 假值判断
* #define slowpath(x) (__builtin_expect(bool(x), 0))
*/
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));
}
这是出现了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) {//在iOS8及以上废弃了zone，(通过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: 类Obj和内存地址指针相关联
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);
}
分析此处源码实现可知这里是alloc的核心实现。主要做了三件事情：
cls->instanceSize(extraBytes);计算需要开辟的内存空间大小obj = (id)calloc(1, size);申请开辟内存空间-
obj->initInstanceIsa(cls, hasCxxDtor);将类和开辟的内存空间地址相关联
开辟内存空间
关联类
alloc流程
2.2 instanceSize 计算开辟内存空间大小
- 第一步
instanceSize
size_t instanceSize(size_t extraBytes) const {
//编译器快速计算内存大小
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;
}
通过符号断点调试。此处执行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);
}
}
- 第三步
align1616字节对齐算法
static inline size_t align16(size_t x) {
return (x + size_t(15)) & ~size_t(15);
}
截屏2020-09-06 19.05.44.png
现代计算机中，内存空间按照字节划分，理论上可以从任何起始地址访问任意类型的变量。但实际中在访问特定类型变量时经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序一个接一个地存放，这就是字节对齐。
一个对象中，第一个属性isa占8字节，一个对象肯定还有其他属性，当无属性时，会预留8字节，即16字节对齐，如果不预留，相当于这个对象的isa和其他对象的isa紧挨着，容易造成访问混乱访问到其他内存地址。16字节对齐后，可以加快CPU读取速度，同时使访问更安全，不会产生访问混乱的情况。
3、init探索
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直接返回self。这里的init是一个构造方法 通过工厂设计（工厂方法模式）。主要是用于给用户提供构造方法入口。这里能使用id强转的原因，主要因为内存字节对齐后，可以使用类型强转为你所需的类型。
4、new 源码探索
new 源码
+ (id)new {
return [callAlloc(self, false/*checkNil*/) init];
}
new直接调用callAlloc，并且实现了init方法。所有new等价于[alloc init]。
在开发中有时生成对象有时需要根据外部变化的条件生成对象例：
-(id)initWithCurrentAge:(int)currentAge{
self = [super init];
if (self) {
self.age = currentAge;
}
return self;
}
此时在用new创建将不会调用构造-(id)initWithCurrentAge:(int)currentAge方法。
5、内存计算示例
- 第一步、创建LGPerson对象，不添加任何属性。此时只有
isa占8个字节。LGPerson对象需要8,按照内存开辟16字节对齐原则应开辟16。结果图1
LGPerson *p1 = [LGPerson alloc];
NSLog(@"objc对象需要的内存大小: %zd", class_getInstanceSize([p1 class]));
NSLog(@"objc对象分配的内存大小: %zd", malloc_size((__bridge const void *)(p1)));
结果图1
结果输出
LGPerson对象需要8字节，内存分配了16
- 第二步
LGPerson添加NSString 类型 name属性
LGPerson对象所需isa + name = 8 + 8 = 16，内存应开辟16。结果图2
截屏2020-09-07 19.27.21.png
@interface LGPerson : NSObject
@property (strong, nonatomic) NSString *name;
@end
LGPerson *p1 = [LGPerson alloc];
NSLog(@"objc对象需要的内存大小: %zd", class_getInstanceSize([p1 class]));
NSLog(@"objc对象分配的内存大小: %zd", malloc_size((__bridge const void *)(p1)));
结果图2
- 第三步 添加
int 类型age属性
LGPerson对象所需isa + name + age = 8 + 8 + 4 = 20。内存应开辟32
截屏2020-09-07 19.28.15.png
@interface LGPerson : NSObject
@property (strong, nonatomic) NSString *name;
@property (assign, nonatomic) int age;
@end
结果图3
截屏2020-09-07 18.43.20.png
结果显示内存分配确为
32。但是对象需要内存确多了4。结合第二步中
namename的操作可以确定是int 类型age出了问题。通过输出确定
int 类型age在此处确为4字节
int类型输出
接下来进入class_getInstanceSize源码查看，进行了什么计算
size_t class_getInstanceSize(Class cls)
{
if (!cls) return 0;
return cls->alignedInstanceSize();
}
uint32_t alignedInstanceSize() const {
return word_align(unalignedInstanceSize());
}
static inline uint32_t word_align(uint32_t x) {
return (x + WORD_MASK) & ~WORD_MASK;
}
发现此处做了一个8字节对齐的操作。为我们int 类型预留了4字节的空间。所以LGPerson对象的内存变成了24
结果图
- 第四步 在添加一个
int 类型age1。查看一下age1是否占用了第三步int的预留空间
结果图
结果显示LGPerson对象所需要内存没有增加。
结果图
结果显示age1确实占据了预留的空间
