由于上篇文章解析 探究 OC 对象创建过程 探索到一部分的内存，我们粗略跳过，这次我们就详细看看
先提出一个疑问
// 引用 #import <objc/runtime.h> #import <malloc/malloc.h>
TObject *obj1 = [TObject new];
obj1.prString = @"TObject";
obj1.prInt = 12;
//
NSLog(@"对象申请的内存空间大小： �%lu",class_getInstanceSize([obj1 class]));
NSLog(@"系统实际开辟的内存空间：%lu",malloc_size((__bridge const void *)(obj1)));
===============
2020-12-08 19:53:15.497897+0800 OC[36634:1466242] 对象申请的内存空间大小： �24
2020-12-08 19:53:15.498207+0800 OC[36634:1466242] 系统实际开辟的内存空间：32
为什么对象申请的内存是 24，而系统开辟出来的确实 32呢？
首先我们看看 对象申请的内存是24是怎么回事
size_t class_getInstanceSize(Class cls)
{
if (!cls) return 0;
return cls->alignedInstanceSize();
}
uint32_t alignedInstanceSize() const {
return word_align(unalignedInstanceSize());
}
// 获取类所有属性的内存大小总和
uint32_t unalignedInstanceSize() const {
ASSERT(isRealized());
return data()->ro()->instanceSize;
}
// 内存对齐算法
static inline uint32_t word_align(uint32_t x) {
return (x + WORD_MASK) & ~WORD_MASK;
}
#ifdef __LP64__
# define WORD_SHIFT 3UL
# define WORD_MASK 7UL
# define WORD_BITS 64
#else
# define WORD_SHIFT 2UL
# define WORD_MASK 3UL
# define WORD_BITS 32
#endif
我们主要看 word_align 方法
(x + WORD_MASK) & ~WORD_MASK 这是二进制的非运算
我们的 TObject 所有熟悉占用内存如下
isa: 8字节;prString 是 string类型 8字节； prInt 是 int 类型是 4字节
8 + 8 + 4 所以是 20 字节
所以 x + WORD_MASK 就是 27 字节
--------------------------------------------
内存对齐为 &运算，需要转化为二进制来计算。可使用二进制计算机计算
// 0001 1011 => 27
// & 表示 与
// 1111 1000 => ~7 表示7的非运算 ，注意 如果进行& 运算的话 就会将 二进制后三位抹去，也就是8字节对齐
// 0001 1000 => 最终结果 24
这就说明 我们的对象申请的内存空间是 8字节对齐的
malloc 的源代码在 libmalloc
从上篇可知，在创建 instanceSize 之后 调用了 calloc 之后我们就跟不进去了
具体实现如下
calloc(size_t num_items, size_t size)
{
void *retval;
retval = malloc_zone_calloc(default_zone, num_items, size);
if (retval == NULL) {
errno = ENOMEM;
}
return retval;
}
void *
malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size)
{
MALLOC_TRACE(TRACE_calloc | DBG_FUNC_START, (uintptr_t)zone, num_items, size, 0);
void *ptr;
if (malloc_check_start && (malloc_check_counter++ >= malloc_check_start)) {
internal_check();
}
// 走到这里 就要陷入死循环了 肯定有问题的
ptr = zone->calloc(zone, num_items, size);
if (malloc_logger) {
malloc_logger(MALLOC_LOG_TYPE_ALLOCATE | MALLOC_LOG_TYPE_HAS_ZONE | MALLOC_LOG_TYPE_CLEARED, (uintptr_t)zone,
(uintptr_t)(num_items * size), 0, (uintptr_t)ptr, 0);
}
MALLOC_TRACE(TRACE_calloc | DBG_FUNC_END, (uintptr_t)zone, num_items, size, (uintptr_t)ptr);
return ptr;
}
这里我们就只能 使用断点 一步一步往下跟了
就跟到 nano_calloc -> _nano_malloc_check_clear ->segregated_size_to_fit
// 这个方法就是关键了
static MALLOC_INLINE size_t
segregated_size_to_fit(nanozone_t *nanozone, size_t size, size_t *pKey)
{
size_t k, slot_bytes;
// 当size 为0的时候 ;给 size 赋值16
if (0 == size) {
size = NANO_REGIME_QUANTA_SIZE; // Historical behavior
}
// size + 15 右移4 为
k = (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM; // round up and shift for number of quanta
//
slot_bytes = k << SHIFT_NANO_QUANTUM; // multiply by power of two quanta size
*pKey = k - 1; // Zero-based!
return slot_bytes;
}
#define NANO_REGIME_QUANTA_SIZE (1 << SHIFT_NANO_QUANTUM) // 16
#define SHIFT_NANO_QUANTUM 4
现在来详细分析一下
按照上文 我们传入的 size 是 24
k = (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM
也就可以理解为
k = (24 + 16 -1) >> 4 // >> 是位移运算
// 0010 0111 ==> 24+16-1 = 39 这是39的二进制形式
右移四位
// 0000 0010 ==> 这就是此时 k 的进制
slot_bytes = k << SHIFT_NANO_QUANTUM;
// k 再左移四位
// 0010 0000 // 表示 32
最终返回 32 字节
系统通过位移运算 截取了二进制的 后四位，也就是16字节对齐
通过位移运算 我们得知 系统是16位对齐的
这也就是 对象申请 24字节 最终返回32 字节的原因了
所以我们可以知道 一个对象在系统占用的内存是 16字节对齐的，并且最小是16字节 （探究 OC 对象创建过程 中讲到 最小返回16字节）
内存结构
可知对象内存中 确实是有一个isa的，经过内存优化，内存排列是尽可能的前部分占满，最后16字节才是多出的部分
image.png
