MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Objective-C 内存管理机制剖析

2021-08-045.0k 阅读

一、Objective-C 内存管理基础概念

在深入剖析 Objective-C 的内存管理机制之前，我们先来明确一些基础概念。

1.1 堆与栈

在计算机内存中，栈（Stack）和堆（Heap）是两种重要的内存区域。栈主要用于存储局部变量、函数参数等，其内存分配和释放由编译器自动管理，遵循后进先出（LIFO）的原则。例如，当一个函数被调用时，它的参数和局部变量会被压入栈中，函数执行完毕后，这些数据会从栈中弹出。

而堆则用于动态分配内存，像通过 alloc 等方法创建的 Objective-C 对象就存储在堆中。堆的内存管理相对复杂，需要程序员手动进行分配和释放（在自动引用计数（ARC）出现之前）。堆的内存分配不遵循特定的顺序，内存空间是离散的，这就需要一些额外的机制来管理内存块的分配和释放。

1.2 对象所有权

在 Objective-C 中，对象所有权是内存管理的核心概念。当一个对象被创建时，创建它的代码就拥有了该对象的所有权。拥有对象所有权意味着负责对象的内存管理，即确保对象在不再被使用时能够正确地释放其所占用的内存。

例如，通过 alloc 方法创建一个对象：

NSObject *obj = [[NSObject alloc] init];

此时，变量 obj 所在的代码块拥有了 obj 所指向对象的所有权。

1.3 引用计数

引用计数（Reference Counting）是 Objective-C 内存管理机制的重要组成部分。每个 Objective-C 对象都有一个引用计数，它记录了当前有多少个变量引用了该对象。当对象的引用计数变为 0 时，意味着没有任何变量指向该对象，此时该对象所占用的内存就可以被安全地释放。

我们可以通过 retain 方法增加对象的引用计数，通过 release 方法减少对象的引用计数。例如：

NSObject *obj1 = [[NSObject alloc] init]; // obj1 引用计数为 1
NSObject *obj2 = obj1; // obj1 引用计数变为 2，因为 obj2 也指向了该对象
[obj1 release]; // obj1 引用计数减为 1
[obj2 release]; // obj1 引用计数减为 0，对象内存被释放

二、手动引用计数（MRC）

在自动引用计数（ARC）出现之前，Objective-C 使用手动引用计数（Manual Reference Counting，MRC）来管理内存。虽然现在 ARC 已经广泛应用，但理解 MRC 对于深入理解内存管理机制仍然非常重要。

2.1 基本内存管理方法

  • alloc：用于分配内存并创建一个新的对象，同时将对象的引用计数设置为 1。例如：
NSString *str = [[NSString alloc] initWithFormat:@"Hello, World!"];
  • retain：增加对象的引用计数。当一个对象需要被多个变量引用，并且每个变量都需要对其生命周期负责时，就需要使用 retain 方法。例如：
NSArray *array = [[NSArray alloc] initWithObjects:@"One", @"Two", nil];
NSArray *arrayCopy = [array retain];
  • release：减少对象的引用计数。当一个对象的所有者不再需要该对象时，就调用 release 方法。如果调用 release 后对象的引用计数变为 0，则对象所占用的内存会被释放。例如：
NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
[dict setObject:@"Value" forKey:@"Key"];
[dict release];
  • autorelease：该方法会将对象放入自动释放池（Autorelease Pool）中，在自动释放池被销毁时，池中的对象会收到 release 消息。这在一些临时对象的创建和管理中非常有用。例如：
NSString *tempStr = [[[NSString alloc] initWithFormat:@"Temp String"] autorelease];

2.2 内存管理规则

在 MRC 下，有以下一些重要的内存管理规则：

  • 谁创建，谁释放：通过 alloc、new、copy 等方法创建的对象，创建者负责调用 release 或 autorelease 来释放对象。
  • 谁 retain，谁 release：如果一个对象被 retain 了，那么必须在适当的时候调用 release 来平衡引用计数。

2.3 内存泄漏与悬空指针

在 MRC 编程中，容易出现内存泄漏（Memory Leak）和悬空指针（Dangling Pointer）的问题。

内存泄漏是指当一个对象不再被使用，但由于引用计数没有正确减少到 0，导致对象所占用的内存无法被释放，从而造成内存浪费。例如：

void memoryLeakExample() {
    NSObject *obj = [[NSObject alloc] init];
    // 这里忘记调用 [obj release]，导致内存泄漏
}

悬空指针是指当一个对象被释放后，指向该对象的指针没有被及时置为 nil，如果后续继续使用这个指针，就会导致程序崩溃。例如：

void danglingPointerExample() {
    NSObject *obj = [[NSObject alloc] init];
    NSObject *anotherObj = obj;
    [obj release];
    // 这里 anotherObj 成为了悬空指针，如果继续使用 [anotherObj doSomething] 会导致崩溃
}

三、自动引用计数（ARC）

为了简化内存管理，降低内存泄漏和悬空指针等问题的发生概率，Objective-C 引入了自动引用计数（Automatic Reference Counting，ARC）。

3.1 ARC 的工作原理

ARC 是一种编译器特性，它在编译时自动在适当的位置插入 retain、release 和 autorelease 代码。编译器会根据对象的生命周期和作用域，分析对象何时不再被使用，并自动生成相应的内存管理代码。

例如，在 ARC 模式下，以下代码：

NSObject *obj = [[NSObject alloc] init];
// 不需要手动调用 [obj release]

编译器会在适当的位置（例如函数结束时）自动插入 release 代码，确保对象在不再被使用时能够正确释放。

3.2 ARC 与所有权修饰符

在 ARC 下，引入了一些所有权修饰符来明确对象的所有权关系。

  • __strong：这是默认的所有权修饰符，表示强引用。一个对象只要有至少一个强引用指向它，它就不会被释放。例如：
__strong NSObject *strongObj = [[NSObject alloc] init];
  • __weak：表示弱引用，弱引用不会增加对象的引用计数。当对象的所有强引用都消失后，对象被释放，所有指向该对象的弱引用会自动被设置为 nil，从而避免了悬空指针的问题。例如：
__strong NSObject *strongObj = [[NSObject alloc] init];
__weak NSObject *weakObj = strongObj;
strongObj = nil;
// 此时 strongObj 所指向的对象因为没有强引用而被释放，weakObj 自动变为 nil
  • __unsafe_unretained：与 __weak 类似，也是弱引用，但它不会自动将指针置为 nil。如果对象被释放，指向它的 __unsafe_unretained 指针就会成为悬空指针，使用时需要特别小心。例如：
__strong NSObject *strongObj = [[NSObject alloc] init];
__unsafe_unretained NSObject *unsafeWeakObj = strongObj;
strongObj = nil;
// 此时 unsafeWeakObj 成为悬空指针，如果继续使用会导致崩溃

3.3 ARC 下的内存管理注意事项

虽然 ARC 大大简化了内存管理，但在一些情况下仍然需要注意避免内存泄漏等问题。

  • 循环引用：当两个或多个对象相互持有强引用时，就会形成循环引用，导致对象无法被释放。例如：
@interface ClassA;
@interface ClassB;

@interface ClassA : NSObject
@property (nonatomic, strong) ClassB *classB;
@end

@interface ClassB : NSObject
@property (nonatomic, strong) ClassA *classA;
@end

@implementation ClassA
@end

@implementation ClassB
@end

void circularReferenceExample() {
    ClassA *a = [[ClassA alloc] init];
    ClassB *b = [[ClassB alloc] init];
    a.classB = b;
    b.classA = a;
    // 这里 a 和 b 相互持有强引用，形成循环引用，导致内存泄漏
}

解决循环引用的方法通常是将其中一个引用改为 __weak 或 __unsafe_unretained。例如：

@interface ClassA;
@interface ClassB;

@interface ClassA : NSObject
@property (nonatomic, strong) ClassB *classB;
@end

@interface ClassB : NSObject
@property (nonatomic, weak) ClassA *classA; // 将这里改为 weak 引用
@end

@implementation ClassA
@end

@implementation ClassB
@end

void fixedCircularReferenceExample() {
    ClassA *a = [[ClassA alloc] init];
    ClassB *b = [[ClassB alloc] init];
    a.classB = b;
    b.classA = a;
    // 此时不会形成循环引用，对象可以正常释放
}

四、自动释放池（Autorelease Pool）

自动释放池是 Objective-C 内存管理机制中的一个重要概念，无论是在 MRC 还是 ARC 下都起着关键作用。

4.1 自动释放池的作用

自动释放池用于延迟对象的释放。当一个对象发送 autorelease 消息时，它并不会立即被释放，而是被放入最近的自动释放池中。当自动释放池被销毁时，池中的所有对象都会收到 release 消息。

这在一些需要创建大量临时对象的场景中非常有用。例如，在一个循环中创建大量的字符串对象：

for (int i = 0; i < 10000; i++) {
    NSString *str = [[NSString alloc] initWithFormat:@"Number %d", i];
    // 这里如果不使用自动释放池，会在循环结束后才释放所有字符串对象，可能导致内存峰值过高
    [str autorelease];
}

如果不使用自动释放池，这些字符串对象会在循环结束后才统一释放，可能导致在循环过程中内存占用过高。而使用自动释放池，可以在循环内部及时释放不再使用的对象，降低内存峰值。

4.2 自动释放池的创建与销毁

在 MRC 下，可以手动创建自动释放池：

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// 创建临时对象并发送 autorelease 消息
NSString *str = [[NSString alloc] initWithFormat:@"Temp String"];
[str autorelease];
[pool drain]; // 释放自动释放池，池中对象收到 release 消息

在 ARC 下，虽然不需要手动调用 drain 方法，但自动释放池的创建和销毁仍然是由编译器自动管理的。例如，在一个函数内部，编译器会在适当的位置插入自动释放池的创建和销毁代码，确保局部变量中的对象能够及时释放。

4.3 自动释放池的嵌套

自动释放池可以嵌套使用。当一个对象发送 autorelease 消息时，它会被放入最近的自动释放池中。例如：

NSAutoreleasePool *outerPool = [[NSAutoreleasePool alloc] init];
NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init];
NSString *str1 = [[NSString alloc] initWithFormat:@"In inner pool"];
[str1 autorelease];
[innerPool drain];
NSString *str2 = [[NSString alloc] initWithFormat:@"In outer pool"];
[str2 autorelease];
[outerPool drain];

在这个例子中，str1 会被放入 innerPool 中，innerPool 被销毁时，str1 会收到 release 消息。而 str2 会被放入 outerPool 中，outerPool 被销毁时，str2 会收到 release 消息。

五、Core Foundation 与内存管理

在 Objective-C 开发中，经常会涉及到 Core Foundation 框架。Core Foundation 是一个基于 C 语言的框架，与 Objective-C 的内存管理机制有一定的关联。

5.1 Core Foundation 内存管理函数

Core Foundation 使用一套类似的内存管理函数，如 CFRetain、CFRelease 等。例如，创建一个 CFStringRef 对象：

CFStringRef cfStr = CFStringCreateWithCString(kCFAllocatorDefault, "Hello, CF", kCFStringEncodingUTF8);
CFRetain(cfStr); // 增加引用计数
CFRelease(cfStr); // 减少引用计数

5.2 Toll-Free Bridging

Objective-C 和 Core Foundation 之间存在一种称为 Toll-Free Bridging 的机制，它允许在某些类型之间无缝转换，并且共享相同的内存管理规则。例如，NSString 和 CFStringRef 之间可以进行 Toll-Free Bridging：

NSString *objcStr = @"Hello, Toll-Free Bridging";
CFStringRef cfStr = (__bridge CFStringRef)objcStr;
// 这里 objcStr 和 cfStr 共享相同的内存，不需要额外的内存分配和释放操作

在进行 Toll-Free Bridging 时，需要注意内存管理的一致性。如果通过 __bridge 转换，那么内存管理仍然由原来的框架负责。如果使用 __bridge_retained，则需要手动调用 CFRelease；如果使用 __bridge_transfer，则 Core Foundation 对象的所有权会转移给 Objective-C，由 Objective-C 的内存管理机制负责释放。

例如：

CFStringRef cfStr = CFStringCreateWithCString(kCFAllocatorDefault, "Hello", kCFStringEncodingUTF8);
NSString *objcStr = (__bridge_transfer NSString *)cfStr;
// 这里 cfStr 的所有权转移给 objcStr，由 Objective-C 内存管理机制负责释放

六、内存管理调试工具

在开发过程中，及时发现和解决内存管理问题至关重要。Xcode 提供了一些强大的内存管理调试工具。

6.1 Instruments

Instruments 是 Xcode 自带的一款性能分析工具，其中的 Memory Graph Debugger 和 Leaks 工具对于内存管理调试非常有用。

  • Memory Graph Debugger：可以直观地查看对象之间的引用关系，帮助发现循环引用等问题。在调试时，通过点击 Xcode 调试栏中的 Memory Graph 按钮，可以打开 Memory Graph Debugger。它会以图形化的方式展示当前内存中的对象，以及对象之间的引用连线。例如，如果发现两个对象之间存在相互引用的连线，就可能存在循环引用问题。
  • Leaks：用于检测内存泄漏。运行 Leaks 工具后，它会在应用程序运行过程中监测内存分配和释放情况，当发现有对象占用的内存无法被释放时，就会报告内存泄漏问题，并给出泄漏对象的相关信息，如对象类型、创建位置等，帮助开发者定位问题代码。

6.2 静态分析

Xcode 的静态分析功能可以在编译时检测一些潜在的内存管理问题。通过选择 Product -> Analyze 菜单，可以对项目进行静态分析。静态分析会检查代码中是否存在未释放的对象、悬空指针等问题，并在 Issue Navigator 中列出所有发现的问题，开发者可以根据提示进行代码修改。

例如，如果代码中存在一个通过 alloc 创建的对象，但没有相应的 release 或 autorelease，静态分析就会给出警告提示。

七、总结内存管理的最佳实践

为了确保应用程序的性能和稳定性，在 Objective-C 内存管理中遵循一些最佳实践是非常有必要的。

  • 使用 ARC：在大多数情况下，应优先使用 ARC。它大大简化了内存管理，减少了手动管理内存带来的错误。只有在一些特殊场景，如与旧代码兼容或需要精确控制内存时，才考虑使用 MRC。
  • 避免循环引用：仔细检查对象之间的引用关系，尤其是在使用 __strong 修饰符时，确保不会形成循环引用。如果可能形成循环引用，将其中一个引用改为 __weak 或 __unsafe_unretained。
  • 合理使用自动释放池：在创建大量临时对象的场景中，合理使用自动释放池可以降低内存峰值。例如，在循环中创建临时对象时，适时创建和销毁自动释放池。
  • 使用调试工具：定期使用 Instruments 和静态分析等调试工具，及时发现和解决内存管理问题。在开发过程中，养成使用这些工具的习惯，能够提高代码的质量和稳定性。

通过深入理解 Objective-C 的内存管理机制，并遵循最佳实践，开发者可以编写出高效、稳定的应用程序，避免因内存管理不当而导致的各种问题。无论是在 MRC 还是 ARC 环境下，对内存管理的掌握都是成为优秀 Objective-C 开发者的关键。同时，不断关注内存管理技术的发展和新特性，也有助于提升开发效率和应用程序的性能。