Objective-C中的对象的内存布局

2021-02-02 本文已影响0人 lieon

Objective-C的本质

Objc的底层实现是C\C++代码：objc->C\C++->汇编->机器语言
Objc的对象，类主要是基于C\C++中的结构体实现

将Objc代码转换为C\C++代码

xcrun  -sdk  iphoneos  clang  -arch  arm64  -rewrite-objc OC源文件  -o  输出的CPP文件

一个OC对象在内存中如何布局的？

NSObject对象的底层实现

OC代码

@interface NSObject <NSObject> {
 Class isa;
}

对应的C++代码

struct NSObject_IMPL {
    Class isa; // 8个字节
};

通过runtime和malloc_size函数获取对应的内存大小,发现 class_getInstanceSize获取到NSObject的实例成员变量所占用的内存为8字节，malloc_size获取到objc指针指向内存大小为16个字节，意思就是说，编译器分配16个字节，实际用到8个字节

    NSObject *obj = [[NSObject alloc] init];
    // 16个字节
    
    // 获得NSObject实例对象的成员变量所占用的大小 >> 8
    NSLog(@"%zd", class_getInstanceSize([NSObject class]));
    
    // 获得obj指针所指向内存的大小 >> 16
    // 编译器分配了16个字节，实际用到8个字节
    NSLog(@"%zd", malloc_size((__bridge const void *)obj));

通过objc源码也能证明这一点，[[NSObject alloc] init];最终会调用 allocWithZone:(struct _NSZone *)zone，落脚到 size_t instanceSize(size_t extraBytes),这个方法会保证实例的最小内存为16个字节，objc源码的调用流程如下:

     + (id)allocWithZone:(struct _NSZone *)zone {
         return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
     }
 
     id
     _objc_rootAllocWithZone(Class cls, malloc_zone_t *zone)
     {
         id obj;

     #if __OBJC2__
         // allocWithZone under __OBJC2__ ignores the zone parameter
         (void)zone;
         obj = class_createInstance(cls, 0);
     #else
         if (!zone) {
             obj = class_createInstance(cls, 0);
         }
         else {
             obj = class_createInstanceFromZone(cls, 0, zone);
         }
     #endif

         if (slowpath(!obj)) obj = callBadAllocHandler(cls);
         return obj;
     }
    
     id class_createInstance(Class cls, size_t extraBytes)
     {
         return _class_createInstanceFromZone(cls, extraBytes, nil);
     }
 
     id
     _class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
                                   bool cxxConstruct = true,
                                   size_t *outAllocatedSize = nil)
     {
         if (!cls) return nil;

         assert(cls->isRealized());

         // Read class's info bits all at once for performance
         bool hasCxxCtor = cls->hasCxxCtor();
         bool hasCxxDtor = cls->hasCxxDtor();
         bool fast = cls->canAllocNonpointer();
        // 获取到实例的大小
         size_t size = cls->instanceSize(extraBytes);
         if (outAllocatedSize) *outAllocatedSize = size;

         id obj;
         if (!zone  &&  fast) {
             obj = (id)calloc(1, size);
             if (!obj) return nil;
             obj->initInstanceIsa(cls, hasCxxDtor);
         }
         else {
             if (zone) {
                 obj = (id)malloc_zone_calloc ((malloc_zone_t *)zone, 1, size);
             } else {
                 obj = (id)calloc(1, size);
             }
             if (!obj) return nil;

             // Use raw pointer isa on the assumption that they might be
             // doing something weird with the zone or RR.
             obj->initIsa(cls);
         }

         if (cxxConstruct && hasCxxCtor) {
             obj = _objc_constructOrFree(obj, cls);
         }

         return obj;
     }
 
     size_t instanceSize(size_t extraBytes) {
         size_t size = alignedInstanceSize() + extraBytes;
         // CF requires all objects be at least 16 bytes.
        // 保证最小大小为16个字节
         if (size < 16) size = 16;
         return size;
     }

继承NSObject的类的对象内存布局

OC代码

     @interface Student : NSObject
     {
         @public
         int _no;
         int _age;
     }
    @end

对应的C++代码

    struct Student_IMPL {
        struct NSObject_IMPL NSObject_IVARS;
        int _no;
        int _age;
    };

    struct NSObject_IMPL {
        Class isa;
    };

等价于

    struct Student_IMPL {
        Class isa;
        int _no;
        int _age;
    };

Student的内存大小分别由isa，_no， _age组成， isa指针占用8个字节，两个int类型的数据，共占用8个字节，所以一个Student对象占用16个字节，编译分配了16个字节，并且Student对象刚好用完

    Student *stu = [[Student alloc] init];
    stu->_no = 4;
    stu->_age = 5;
    // 16
    NSLog(@"%zd", class_getInstanceSize([Student class]));
    // 16
    NSLog(@"%zd", malloc_size((__bridge const void *)stu));

从Xcode中ViewMemory也可以看出

image.png

可视化的内存布局如下

image.png
同理，具体继承关系内存布局如下
- OC代码

@interface Person : NSObject
{
    @public
    int _age;
}
@end

@interface Student : Person
{
    @public
    int _no;
}
@end

@interface Graduate : Student
{
    @public
    int grade;
}
@end

@implementation Graduate

@end

对应的C++代码

struct NSObject_IMPL {
    Class isa;
};

struct Person_IMPL {
    struct NSObject_IMPL NSObject_IVARS; // 8
    int _age; // 4
};

struct Student_IMPL {
    struct Person_IMPL Person_IVARS; 
    int _no; 
}; 


 Student *stu = [[Student alloc] init];
 stu->_age = 2;
 stu->_no = 3;
 NSLog(@"stu - %zd", class_getInstanceSize([Student class]));  // 16
 NSLog(@"stu - %zd", malloc_size((__bridge const void *)stu)); // 16

 Graduate *grade = [[Graduate alloc] init];
grade->_age = 7;
grade->_no = 8;
grade->grade = 9;
NSLog(@"grade - %zd", class_getInstanceSize([Graduate class])); // 24
NSLog(@"grade - %zd", malloc_size((__bridge const void *)grade)); // 32

64位系统下，综上可以看出，编译给Person分配了16个字节，实际用到12个字节，还有4个字节没有使用， Student对象继承Person对象,Student对象实际会继续使用Person对象内存中没有使用的4个字节，所以Student对象的内存大小是16个字节，Grade继承Student类，实际占用的内存大小为20个字节，由于内存对齐原因，以8个字节内存对齐，所以会使用24个字节，编译器分配了32个字节
内存对齐：结构体的大小必须是最大成员大小的倍数

Student内存数据.png

Student内存布局.png

Grade内存数据.png

总结

说白了就是多了一个isa指针，isa的大小由编译器，系统决定，内存分配编译器按照内存对齐进行大小分配，分配的内存，不一定会完全用完
class_getInstanceSize获取实例对象至少占用的内存
malloc_size获取编译器给实例对象对象分配的内存的大小
在 libmalloc源码中定义了 #define NANO_MAX_SIZE 256 /* Buckets sized {16, 32, 48, 64, 80, 96, 112, ...}表示在iOS系统中每次最少分配16个字节，或者每次分配的字节数是16的倍数，每次最多分配256字节

Objective-C中的对象的内存布局

Objective-C的本质

一个OC对象在内存中如何布局的？

NSObject对象的底层实现

继承NSObject的类的对象内存布局

总结

猜你喜欢

热点阅读