内存管理-iOS内存分区

在本文中，你将了解到如下内容：

1. iOS程序在内存中的分区
2. iOS内存中各分区存储的数据
3. 栈区的大小限制
4. 单个APP的可使用内存大小
5. 堆和栈的一些比较

引言

iOS的存储器包括RAM（random access memory，运行内存）和ROM（Read-Only Memory，只读存储器）。本文仅讨论程序在运行时RAM中的内存分配情况。

内存的5大分区

1. 栈区：存放函数的参数和局部变量等。存在于用户虚拟地址的顶部，在程序的运行过程中，可以动态的向低地址扩展。由编译器自动分配，在不需要的时候由编译器自动释放。
2. 堆区：存放通过new、alloc、malloc等方式创建的对象。在程序的运行过程中，可以动态的向高地址扩展。由程序员申请和释放内存，一般是创建一个对象，最后就需要释放一个对象，否则就是内存泄漏。
3. BBS段(未初始化数据区)：存储程序中未初始化的全局变量和静态变量。只进行了声明但未赋值的变量，运行前值全部是0。程序运行过程中内存一直存在，程序运行结束后由系统自动释放。
4. 数据段(未初始化数据区)：存储常量、已初始化的全局变量和静态变量。程序运行过程中内存一直存在，程序运行结束后由系统自动释放。
5. 代码段：存放由代码编译生成的二进制代码(如函数体等)。静态的、只读的。程序运行过程中内存一直存在，程序运行结束后由系统自动释放。

各区数据地址测试

我们运行如下代码：

NSInteger a = 10; // 已初始化全局变量(数据段)
NSInteger b; // 未初始化全局变量(BBS段)

int main(int argc, char * argv[]) {
    
    NSString * appDelegateClassName;
    @autoreleasepool {
        appDelegateClassName = NSStringFromClass([AppDelegate class]);
    }
    
    @autoreleasepool {
        static NSInteger c = 20; // 已初始化静态变量(数据段)
        static NSInteger d; // 未初始化静态变量(BBS段)

        NSInteger e = 30; // 局部变量(栈区)
        NSInteger f; // 局部变量(栈区)

        NSString *g = @"123"; // 常量字符串(数据段)
        
        NSObject *h = [NSObject new]; // 局部变量对象(堆区)
        NSMutableArray *i = [[NSMutableArray alloc] init]; // 局部变量对象(堆区)
        
        printf("常量字符串 g: %p \n", g);
        printf("已初始化全局变量 a: %p \n", &a);
        printf("已初始化静态变量 c: %p \n", &c);
        printf("未初始化全局变量 b: %p \n", &b);
        printf("未初始化静态变量 d: %p \n", &d);
        printf("栈: e: %p \n", &e);
        printf("栈: f: %p \n", &f);
        printf("堆: h: %p \n", h);
        printf("堆: i: %p \n", i);
    }
    
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

打印结果如下：

常量字符串 g: 0x101df5060 
已初始化全局变量 a: 0x101dfa820 
已初始化静态变量 c: 0x101dfa828 
未初始化全局变量 b: 0x101dfa8f8 
未初始化静态变量 d: 0x101dfa8f0 
栈: e: 0x7ffeede0cc90 
栈: f: 0x7ffeede0cc88 
堆: h: 0x600003d34000 
堆: i: 0x600003169650 

我们可以很清晰的看到：

• 数据的分配分隔出了5个区域。
• 数据段的a和c、BBS段的b和d，栈区的e和f，处在同个数据区的两个变量地址都是连续的。
• 堆区的两个对象地址不连续的原因是堆区的内存并不是连续的，而是一块一块的大小不等的内存块。

栈的大小限制

Thread Management这篇文章中，有对各线程中的栈的大小做出说明。

• 主线程中栈的大小限制为1M，子线程中栈的大小限制为512KB。超出限制，就会出现堆栈溢出的错误。
• 栈最小为16KB，并且其大小必须是4KB的倍数。
• 创建线程时，栈的内存空间就已经留出，但是实际的内存页面是直到使用时才会创建的。

单个APP可使用内存大小

以下数据为从此处搬运。

机型	内存占用量	总内存量	崩溃时内存占有比例
iPad1	127MB	256MB	49%
iPad2	275MB	512MB	53%
iPad3	645MB	1024MB	62%
iPad4	585MB	1024MB	57% (iOS 8.1)
iPad Mini 1st Generation	297MB	512MB	58%
iPad Mini retina	696MB	1024MB	68% (iOS 7.1)
iPad Air	697MB	1024MB	68%
iPad Air 2	1383MB	2048MB	68% (iOS 10.2.1)
iPad Pro 9.7"	1395MB	1971MB	71% (iOS 10.0.2 (14A456))
iPad Pro 10.5”	3057	4000	76% (iOS 11 beta4)
iPad Pro 12.9” (2015)	3058	3999	76% (iOS 11.2.1)
iPad Pro 12.9” (2017)	3057	3974	77% (iOS 11 beta4)
iPad Pro 11.0” (2018)	2858	3769	76% (iOS 12.1)
iPad Pro 12.9” (2018, 1TB)	4598	5650	81% (iOS 12.1)
iPad 10.2	1844	2998	62% (iOS 13.2.3)
iPod touch 4th gen	130MB	256MB	51% (iOS 6.1.1)
iPod touch 5th gen	286MB	512MB	56% (iOS 7.0)
iPhone4	325MB	512MB	63%
iPhone4s	286MB	512MB	56%
iPhone5	645MB	1024MB	62%
iPhone5s	646MB	1024MB	63%
iPhone6	645MB	1024MB	62% (iOS 8.x)
iPhone6+	645MB	1024MB	62% (iOS 8.x)
iPhone6s	1396MB	2048MB	68% (iOS 9.2)
iPhone6s+	1392MB	2048MB	68% (iOS 10.2.1)
iPhoneSE	1395MB	2048MB	69% (iOS 9.3)
iPhone7	1395	2048MB	68% (iOS 10.2)
iPhone7+	2040MB	3072MB	66% (iOS 10.2.1)
iPhone8	1364	1990MB	70% (iOS 12.1)
iPhone X	1392	2785	50% (iOS 11.2.1)
iPhone XS	2040	3754	54% (iOS 12.1)
iPhone XS Max	2039	3735	55% (iOS 12.1)
iPhone XR	1792	2813	63% (iOS 12.1)
iPhone 11	2068	3844	54% (iOS 13.1.3)
iPhone 11 Pro Max	2067	3740	55% (iOS 13.2.3)

堆和栈的区别

1. 申请方式和回收方式
   • 栈：由系统自动分配和释放。
   • 堆：由程序员分配和释放。
2. 申请的内存大小限制
   • 栈：在iOS系统中，主线程限制为1M，子线程限制为512KB。
   • 堆：在iOS系统中，各线程共用同一块内存空间。堆的大小受限于系统的虚拟内存，可使用空间较大。
3. 内存分配方式比较
   • 栈：只要栈的剩余空间大于所申请的空间，系统就会分配可用地址，否则将报栈溢出的异常。
   • 堆：系统会遍历空闲内存地址链表，寻找到第一个可用空间大于申请空间的节点，然后将节点从链表中移除，并将该节点的内存空间分配给程序。
4. 分配效率的比较
   • 栈：由系统自动分配，速度快。
   • 堆：需要遍历空闲内存地址链表，一般速度较慢，而且容易产生内存碎片。
5. 分配方式的比较
   • 栈：静态分配和动态分配
   • 堆：动态分配，不支持静态分配