内存对齐原理

字节对齐算法

先了解一下字节对齐算法

static inline size_t word_align(size_t x) {
    return (x + WORD_MASK) & ~WORD_MASK;
}

以传入的参数为11为例，先来计算一下结果
（11+ 7）& ～7
= （00001011 + 000001111） & （11111000）
= 00010010 & 11111000
= 00010000
= 16
可见，该算法会对x向上取8的整数倍，如果是8的整数倍，则返回x一样的大小。

@interface Person : NSObject

@property (nonatomic, assign) int age;

@property (nonatomic, assign) double height;

@property (nonatomic, assign) NSString *name;

@property (nonatomic, assign) BOOL isStudent;

@end

用以上Person类来举例，该对象的isa指针8字节，age是4字节，height是8字节，name指针是8字节，isStudent是1字节，总共29字节。
我们用class_getInstanceSize打印一下。

在这里，成员变量的大小占了32字节，之所以会这样，是因为这里进行了8字节对齐处理。
如果不采用8字节对齐，那么读取成员变量的时候，要改变3次读取方式：
一开始是读取8个字节（isa），然后变成读取4个字节（age），再接着变成8个字节，读取两次（height和name），最后再变成读取1个字节
如果采用8字节对齐的方式，就可以每次都读取8字节，不必改变读取方式，减少系统开销，读取更加迅速。

结构体内存对齐

结构体内存对齐原则

• 结构体（struct）或联合体（union）的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的存储位置要从该成员大小或成员的子成员大小（只要该成员有子成员，比如说是数组结构体等）的整数倍开始（比如int是4字节，则要从4的整数倍地址开始存储）
• 结构体作为成员，如果一个结构体里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（struct a里面有struct b，b里面有char，int，double等元素，那b应该从8的整数倍开始存储）
• 结构体的总大小，也就是sizeof的结果，必须是其内部最大成员大小的整数倍，不足的要补齐。

代码示例

#import <UIKit/UIKit.h>
#import "AppDelegate.h"
#import "LGPerson.h"
#import <objc/runtime.h>

struct LGStruct1 {
    double a;       // 8    [0 7]
    char b;         // 1    [8]
    int c;          // 4    (9 10 11 [12 13 14 15]  要从4的整数倍开始
    short d;        // 2    [16 17] 24 必须是其内部最大成员大小的整数倍，不足的要补齐
}struct1;

struct LGStruct2 {
    double a;       // 8    [0 7]
    int b;          // 4    [8 9 10 11]
    char c;         // 1    [12]
    short d;        // 2    (13 [14 15] 16  要从2整数倍开始；不足的要补齐
}struct2;


int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {

        LGPerson *person = [LGPerson alloc];
        person.name      = @"Bruce";
        person.nickName  = @"bu";
        person.age       = 18;
        person.height    = 190.5;
        person.c1        = 'a';
        person.c2        = 'b';

        NSLog(@"%lu-%lu",sizeof(struct1),sizeof(struct2));

        appDelegateClassName = NSStringFromClass([AppDelegate class]);
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

我们来看看结果：

malloc_size探索

用malloc_size可以打印出来实例对象占用的内存大小

#import <UIKit/UIKit.h>
#import "AppDelegate.h"
#import "LGPerson.h"
#import <objc/runtime.h>

@interface Person : NSObject

@property (nonatomic, assign) int age;

@property (nonatomic, assign) double height;

@property (nonatomic, strong) NSString *name;

@property (nonatomic, strong) NSString *nickName;

@property (nonatomic, assign) BOOL isStudent;

@end


@implementation Person



@end

int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {

        Person *obj = [Person alloc];
		NSLog(@"%lu-%lu",class_getInstanceSize(obj.class), malloc_size((__bridge const void *)(obj)));
        appDelegateClassName = NSStringFromClass([AppDelegate class]);
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

结果：

2021-12-06 23:55:01.961471+0800 HelloWorld[4659:83689] 40-48

48就令人费解，为什么不是8字节对齐，为什么不是40而是48？

其实，在libmalloc-317.40.8源码中找到了核心代码，内存对齐以16字节的方式

#define SHIFT_NANO_QUANTUM		4
#define NANO_REGIME_QUANTA_SIZE	(1 << SHIFT_NANO_QUANTUM)	// 16

static MALLOC_INLINE size_t
segregated_size_to_fit(nanozone_t *nanozone, size_t size, size_t *pKey)
{
	size_t k, slot_bytes;

	if (0 == size) {
		size = NANO_REGIME_QUANTA_SIZE; // Historical behavior
	}
	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;
}