Objective-C对象的内存分配

cover.jpg

一个NSObject对象占用多少内存？

本章主要研究一个OC对象在内存中是如何布局和占用多少内存的。后面主要通过把OC代码转为C++代码和结合Apple的源码分析问题。
我们平时编写的Objective-C代码，底层实现其实都是C\C++代码。

大体流程.png

Objective-C的面向对象都是基于C\C++的结构体实现的。

将Objective-C代码转换为C\C++代码

-sdk:指定平台，不同平台，代码肯定是不一样的（Windows，Mac，iOS）
-arch:指定架构（模拟器:i386  32bit:armv7  64bit:arm64）
-rewrite-objc:重写objc代码

• xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc OC源文件 -o 输出的CPP文件
• 如果需要链接其他框架，使用-framework参数。比如-framework UIKit

NSObject的底层实现

@interface NSObject  {
    Class isa;
}
转为C++代码
// NSObject Implementation
// isa 在64位机器上占8个字节  32位机器上占4个字节
struct NSObject_IMPL {
    Class isa;
};

// Class 是指向结构体的指针
typedef struct objc_class *Class;

根据以上代码分析，那一个NSObject对象是不是就占用8个字节呢？接下来验证一下。

NSObject *obj = [[NSObject alloc] init];
// 获得 NSObject 类的实例对象的成员变量所占用的内存大小
size_t instanceSize = class_getInstanceSize([NSObject class]);
NSLog(@"%zd", instanceSize);    // 8

// 获得 obj 指针所指向内存的大小
// 此处需要将OC指针类型转为C语言指针类型，做个桥接
size_t instanceSize2 = malloc_size((__bridge const void *)(obj));
NSLog(@"%zd", instanceSize2);   // 16

为什么这两个函数获取到的大小不一样呢？到底哪个是正确的。
下载源码https://opensource.apple.com/tarballs/objc4/（选编号最大的下载，一般是最新的，当前最新的是 objc4-779.1
）看看这两个函数的具体实现。
如何去找到具体实现 :打开源码项目 --> 全局搜索要找的方法，如 class_getInstanceSize --> 搜索结果有很多，有声明文件，也有旧的文件，所以记得在.mm文件中找，如果文件名带有old的直接忽略，肯定不是最新的

全局搜索：class_getInstanceSize

// objc-class.mm
size_t class_getInstanceSize(Class cls)
{
    if (!cls) return 0;
    return cls->alignedInstanceSize();
}
// Class's ivar size rounded up to a pointer-size boundary.
uint32_t alignedInstanceSize() const {
    return word_align(unalignedInstanceSize());
}

全局搜索：allocWithZone（malloc_size最终调用的是这个方法）

// NSObject.mm
// Replaced by ObjectAlloc
+ (id)allocWithZone:(struct _NSZone *)zone {
    return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
}

// objc-runtime-new.mm
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);
}

// objc-runtime-new.mm
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;

    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);
    }
    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);
}

// objc-runtime-new.h
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;
}

// 此方法是做了内存对齐
uint32_t alignedInstanceSize() const {
    return word_align(unalignedInstanceSize());
}

注意上面代码：obj = (id)calloc(1, size);为对象分配内存空间，且size = cls->instanceSize(extraBytes);（size是通过cls的instanceSize方法计算出来的）instanceSize方法内部有个条件判断，if (size < 16) size = 16;所以OC对象至少是16个字节，注意代码里的注释“CF requires all objects be at least 16 bytes.(CF要求所有对象至少为16个字节)”

对以上两个获取对象内存的方法做个小总结，在以后的使用中不要混淆了

对比	class_getInstanceSize()	malloc_size()
作用	创建一个实例对象，至少需要多少内存	创建一个实例对象，实际上分配了多少内存
头文件	#import	#import

知道了NSObject的内存分配，接下来我们看看下面这个例子（64位机器上）

@interface Person : NSObject
{
    int _age;
}
@end
转为C++代码最终结果
struct Person_IMPL {
    Class isa;  // 8
    int _age;   // 4
};
// 内存对齐：结构体的最终大小必须是最大成员大小的倍数

isa是指针类型：占用8个字节
int：占用4个字节
根据上面的分析，8+4 < 16，所以此时Person的实例对象占用了16个字节。
如果抛开if (size < 16) size = 16;这个条件，单从结构体内存对齐的方式分析，此时Person的实例对象也是占用了16个字节。

内存分配注意点

@interface Person : NSObject
{
    int _age;
}
@end
转为C++代码最终结果
struct Person_IMPL {
    Class isa;
    int _age;
};
// Person的实例对象占用16个字节

@interface Student : Person
{
    int _no;
    int _height;
}
@end
转为C++代码最终结果
struct Student_IMPL {
    Class isa;  // 8
    int _age;   // 4
    int _no;    // 4
    int _height;// 4
};
// Student的实例对象占用32个字节

Student *studetn = [[Student alloc] init];
NSLog(@"%zd", class_getInstanceSize([Student class]));  // 24
NSLog(@"%zd", sizeof(struct Student_IMPL));             // 24
NSLog(@"%zd",  malloc_size((__bridge const void *)(studetn)));  // 32

class_getInstanceSize()：实例对象至少需要多少个字节
sizeof()：计算结构体的大小
以上两种方式都会考虑结构体的内存对齐规则（alignedInstanceSize方法中有体现），所以此处是24，并非20；
但是为什么malloc_size ()的值是32呢？这里需要注意一下，上面分析NSObject的内存分配时，有个方法_class_createInstanceFromZone这里面的obj = (id)calloc(1, size);此时这里传入的size应该是24，告诉编译器需要24个字节就够了，但是返回了32个字节的内存空间。是calloc这个方法在作妖。其实calloc这个方法内部有很多内存分配方式，和规则，相关源码下载(https://opensource.apple.com/tarballs/libmalloc/)。

苹果的内存对齐规则：在iOS中，OC对象在堆上分配内存，都是16的倍数，内部有一个宏#define NANO_MAX_SIZE 256 /* Buckets sized {16, 32, 48, ..., 256} */，如果申请的内存小于NANO_MAX_SIZE即256字节，则都会是按16的倍数分配，也可以理解为苹果自己的内存对齐规则，如果是超出了256字节，则会按其它方式分配。
这里的Buckets可以理解为装有固定大小(16的倍数，最大256)的内存的桶，当你申请内存时，会为你分配合适的内存空间，也是内存的一种优化，提高内存分配的速度。

sizeof()注意点

• sizeof()接收的参数是一个数据类型，并不是类对象；
• sizeof()不是函数，而是一个运算符，在编译的时候就变成了一个常数；例如：sizeof(int)在编译的时候直接就变成了4，而不是在运行时去计算。

总结

• 当需要获取一个OC对象至少需要多少内存时，使用class_getInstanceSize()方法；
• 当需要获取一个OC对象实际分配的内存时，使用malloc_size()方法；