避免 Objective-C 类内存泄漏：循环引用的 3 种常见场景与解决方案

在 Objective-C 开发中，内存泄漏常由循环引用引起。循环引用发生在两个或多个对象相互持有强引用，导致 ARC（自动引用计数）无法释放内存。这会浪费资源，甚至引发崩溃。下面我将介绍三种常见场景及其解决方案，帮助您预防内存泄漏。每个场景包括问题描述、原因分析和具体解决步骤，确保代码健壮可靠。

场景 1: Block 中捕获 self 导致循环引用

问题描述：
在 Objective-C 中，block 常用于异步操作（如网络请求或动画）。如果 block 内部直接使用 self，且 block 被 self 持有的对象（如属性或实例变量）强引用，就会形成循环：self → 持有 block → block 捕获 self → self。这会导致 self 无法释放，引发内存泄漏。

解决方案：
使用弱引用（__weak）打破循环。在 block 外部创建 weakSelf，并在 block 内部使用它。如果需要在 block 内保证 weakSelf 存活，可添加强引用临时变量。

// 示例代码：避免 block 循环引用
__weak typeof(self) weakSelf = self;
self.completionBlock = ^{
    __strong typeof(weakSelf) strongSelf = weakSelf; // 临时强引用，防止 weakSelf 在 block 执行中被释放
    if (strongSelf) {
        [strongSelf doSomething]; // 安全使用 self
    }
};

关键点：

• 始终在 block 外定义 __weak typeof(self) weakSelf = self。
• 在 block 内部，使用 __strong 临时变量避免 weakSelf 被提前释放。
• 测试工具：使用 Xcode 的 Memory Graph Debugger 检查引用关系。

场景 2: Delegate 模式中的强引用循环

问题描述：
在委托（delegate）模式中，对象 A 持有对象 B 的 delegate 属性（如 @property (strong, nonatomic) id<MyDelegate> delegate;）。如果对象 B 也直接或间接持有对象 A 的强引用（例如通过父视图或数组），就会形成循环：A → delegate（指向 B）→ B → 持有 A → A。这会导致两者都无法释放。

解决方案：
将 delegate 属性声明为 weak 而非 strong。这确保 delegate 引用不会增加对象的引用计数，从而打破循环。

// 示例代码：正确声明 delegate 属性
@interface MyViewController : UIViewController
@property (weak, nonatomic) id<MyDelegate> delegate; // 使用 weak 避免强引用
@end

// 使用方：设置 delegate 时无需额外处理
MyViewController *vc = [[MyViewController alloc] init];
vc.delegate = self; // self 不会被强持有

关键点：

• 所有 delegate 属性应定义为 @property (weak, nonatomic) ...。
• 如果 delegate 可能为 nil（如协议方法），在调用前检查 if ([self.delegate respondsToSelector:@selector(method)])。
• 避免使用 assign（它不适用于对象类型），优先用 weak。

场景 3: 父子对象相互持有强引用

问题描述：
在对象层次结构中（如自定义视图或数据模型），父对象强引用子对象（如 @property (strong, nonatomic) ChildObject *child;），而子对象又强引用父对象（如 @property (strong, nonatomic) ParentObject *parent;）。这形成循环：父 → 子 → 父 → ...。常见于复杂 UI 组件或 Core Data 关系，导致整个对象树无法释放。

解决方案：
在子对象中使用弱引用（weak）指向父对象。同时，确保父对象释放时手动断开引用。

// 示例代码：父子对象避免循环
@interface ParentObject : NSObject
@property (strong, nonatomic) ChildObject *child;
@end

@interface ChildObject : NSObject
@property (weak, nonatomic) ParentObject *parent; // 子对象使用 weak 引用父对象
@end

// 使用时：
ParentObject *parent = [[ParentObject alloc] init];
ChildObject *child = [[ChildObject alloc] init];
parent.child = child;
child.parent = parent; // 弱引用，不会增加引用计数

关键点：

• 子对象的父引用必须为 @property (weak, nonatomic) ...。
• 在 dealloc 方法中，手动置 nil 引用（如 self.child = nil;），确保及时释放。
• 对于集合类（如 NSArray），避免存储强引用对象，改用弱引用容器（如 NSPointerArray）。

总结预防循环引用的最佳实践

• 使用弱引用（weak）：在 block、delegate 和父子关系中使用 __weak 或 weak 属性。
• 代码审查：定期检查属性声明（确保 strong 仅用于必要场景）和 block 使用。
• 工具辅助：
  • 启用 Xcode 的 Static Analyzer（Product > Analyze）检测潜在循环。
  • 运行 Instruments 的 Leaks 工具进行内存测试。
• ARC 注意事项：ARC 不能自动处理循环引用，开发者需主动管理。
  遵循这些方法，可显著减少内存泄漏风险，提升应用稳定性。如果您有具体代码案例，我可以进一步分析优化！

避免 Objective-C 类内存泄漏：循环引用的 3 种常见场景与解决方案

在 Objective-C 开发中，内存泄漏常由循环引用引起。循环引用发生在两个或多个对象相互持有强引用，导致 ARC（自动引用计数）无法释放内存。这会浪费资源，甚至引发崩溃。下面我将介绍三种常见场景及其解决方案，帮助您预防内存泄漏。每个场景包括问题描述、原因分析和具体解决步骤，确保代码健壮可靠。

场景 1: Block 中捕获 self 导致循环引用

问题描述：
在 Objective-C 中，block 常用于异步操作（如网络请求或动画）。如果 block 内部直接使用 self，且 block 被 self 持有的对象（如属性或实例变量）强引用，就会形成循环：self → 持有 block → block 捕获 self → self。这会导致 self 无法释放，引发内存泄漏。

解决方案：
使用弱引用（__weak）打破循环。在 block 外部创建 weakSelf，并在 block 内部使用它。如果需要在 block 内保证 weakSelf 存活，可添加强引用临时变量。

// 示例代码：避免 block 循环引用
__weak typeof(self) weakSelf = self;
self.completionBlock = ^{
    __strong typeof(weakSelf) strongSelf = weakSelf; // 临时强引用，防止 weakSelf 在 block 执行中被释放
    if (strongSelf) {
        [strongSelf doSomething]; // 安全使用 self
    }
};

关键点：

• 始终在 block 外定义 __weak typeof(self) weakSelf = self。
• 在 block 内部，使用 __strong 临时变量避免 weakSelf 被提前释放。
• 测试工具：使用 Xcode 的 Memory Graph Debugger 检查引用关系。

场景 2: Delegate 模式中的强引用循环

问题描述：
在委托（delegate）模式中，对象 A 持有对象 B 的 delegate 属性（如 @property (strong, nonatomic) id<MyDelegate> delegate;）。如果对象 B 也直接或间接持有对象 A 的强引用（例如通过父视图或数组），就会形成循环：A → delegate（指向 B）→ B → 持有 A → A。这会导致两者都无法释放。

解决方案：
将 delegate 属性声明为 weak 而非 strong。这确保 delegate 引用不会增加对象的引用计数，从而打破循环。

// 示例代码：正确声明 delegate 属性
@interface MyViewController : UIViewController
@property (weak, nonatomic) id<MyDelegate> delegate; // 使用 weak 避免强引用
@end

// 使用方：设置 delegate 时无需额外处理
MyViewController *vc = [[MyViewController alloc] init];
vc.delegate = self; // self 不会被强持有

关键点：

• 所有 delegate 属性应定义为 @property (weak, nonatomic) ...。
• 如果 delegate 可能为 nil（如协议方法），在调用前检查 if ([self.delegate respondsToSelector:@selector(method)])。
• 避免使用 assign（它不适用于对象类型），优先用 weak。

场景 3: 父子对象相互持有强引用

问题描述：
在对象层次结构中（如自定义视图或数据模型），父对象强引用子对象（如 @property (strong, nonatomic) ChildObject *child;），而子对象又强引用父对象（如 @property (strong, nonatomic) ParentObject *parent;）。这形成循环：父 → 子 → 父 → ...。常见于复杂 UI 组件或 Core Data 关系，导致整个对象树无法释放。

解决方案：
在子对象中使用弱引用（weak）指向父对象。同时，确保父对象释放时手动断开引用。

// 示例代码：父子对象避免循环
@interface ParentObject : NSObject
@property (strong, nonatomic) ChildObject *child;
@end

@interface ChildObject : NSObject
@property (weak, nonatomic) ParentObject *parent; // 子对象使用 weak 引用父对象
@end

// 使用时：
ParentObject *parent = [[ParentObject alloc] init];
ChildObject *child = [[ChildObject alloc] init];
parent.child = child;
child.parent = parent; // 弱引用，不会增加引用计数

关键点：

• 子对象的父引用必须为 @property (weak, nonatomic) ...。
• 在 dealloc 方法中，手动置 nil 引用（如 self.child = nil;），确保及时释放。
• 对于集合类（如 NSArray），避免存储强引用对象，改用弱引用容器（如 NSPointerArray）。

总结预防循环引用的最佳实践

• 使用弱引用（weak）：在 block、delegate 和父子关系中使用 __weak 或 weak 属性。
• 代码审查：定期检查属性声明（确保 strong 仅用于必要场景）和 block 使用。
• 工具辅助：
  • 启用 Xcode 的 Static Analyzer（Product > Analyze）检测潜在循环。
  • 运行 Instruments 的 Leaks 工具进行内存测试。
• ARC 注意事项：ARC 不能自动处理循环引用，开发者需主动管理。
  遵循这些方法，可显著减少内存泄漏风险，提升应用稳定性。如果您有具体代码案例，我可以进一步分析优化！

避免 Objective-C 类内存泄漏：循环引用的 3 种常见场景与解决方案

在 Objective-C 开发中，内存泄漏常由循环引用引起。循环引用发生在两个或多个对象相互持有强引用，导致 ARC（自动引用计数）无法释放内存。这会浪费资源，甚至引发崩溃。下面我将介绍三种常见场景及其解决方案，帮助您预防内存泄漏。每个场景包括问题描述、原因分析和具体解决步骤，确保代码健壮可靠。

场景 1: Block 中捕获 self 导致循环引用

问题描述：
在 Objective-C 中，block 常用于异步操作（如网络请求或动画）。如果 block 内部直接使用 self，且 block 被 self 持有的对象（如属性或实例变量）强引用，就会形成循环：self → 持有 block → block 捕获 self → self。这会导致 self 无法释放，引发内存泄漏。

解决方案：
使用弱引用（__weak）打破循环。在 block 外部创建 weakSelf，并在 block 内部使用它。如果需要在 block 内保证 weakSelf 存活，可添加强引用临时变量。

// 示例代码：避免 block 循环引用
__weak typeof(self) weakSelf = self;
self.completionBlock = ^{
    __strong typeof(weakSelf) strongSelf = weakSelf; // 临时强引用，防止 weakSelf 在 block 执行中被释放
    if (strongSelf) {
        [strongSelf doSomething]; // 安全使用 self
    }
};

关键点：

• 始终在 block 外定义 __weak typeof(self) weakSelf = self。
• 在 block 内部，使用 __strong 临时变量避免 weakSelf 被提前释放。
• 测试工具：使用 Xcode 的 Memory Graph Debugger 检查引用关系。

场景 2: Delegate 模式中的强引用循环

问题描述：
在委托（delegate）模式中，对象 A 持有对象 B 的 delegate 属性（如 @property (strong, nonatomic) id<MyDelegate> delegate;）。如果对象 B 也直接或间接持有对象 A 的强引用（例如通过父视图或数组），就会形成循环：A → delegate（指向 B）→ B → 持有 A → A。这会导致两者都无法释放。

解决方案：
将 delegate 属性声明为 weak 而非 strong。这确保 delegate 引用不会增加对象的引用计数，从而打破循环。

// 示例代码：正确声明 delegate 属性
@interface MyViewController : UIViewController
@property (weak, nonatomic) id<MyDelegate> delegate; // 使用 weak 避免强引用
@end

// 使用方：设置 delegate 时无需额外处理
MyViewController *vc = [[MyViewController alloc] init];
vc.delegate = self; // self 不会被强持有

关键点：

• 所有 delegate 属性应定义为 @property (weak, nonatomic) ...。
• 如果 delegate 可能为 nil（如协议方法），在调用前检查 if ([self.delegate respondsToSelector:@selector(method)])。
• 避免使用 assign（它不适用于对象类型），优先用 weak。

场景 3: 父子对象相互持有强引用

问题描述：
在对象层次结构中（如自定义视图或数据模型），父对象强引用子对象（如 @property (strong, nonatomic) ChildObject *child;），而子对象又强引用父对象（如 @property (strong, nonatomic) ParentObject *parent;）。这形成循环：父 → 子 → 父 → ...。常见于复杂 UI 组件或 Core Data 关系，导致整个对象树无法释放。

解决方案：
在子对象中使用弱引用（weak）指向父对象。同时，确保父对象释放时手动断开引用。

// 示例代码：父子对象避免循环
@interface ParentObject : NSObject
@property (strong, nonatomic) ChildObject *child;
@end

@interface ChildObject : NSObject
@property (weak, nonatomic) ParentObject *parent; // 子对象使用 weak 引用父对象
@end

// 使用时：
ParentObject *parent = [[ParentObject alloc] init];
ChildObject *child = [[ChildObject alloc] init];
parent.child = child;
child.parent = parent; // 弱引用，不会增加引用计数

关键点：

• 子对象的父引用必须为 @property (weak, nonatomic) ...。
• 在 dealloc 方法中，手动置 nil 引用（如 self.child = nil;），确保及时释放。
• 对于集合类（如 NSArray），避免存储强引用对象，改用弱引用容器（如 NSPointerArray）。

总结预防循环引用的最佳实践

• 使用弱引用（weak）：在 block、delegate 和父子关系中使用 __weak 或 weak 属性。
• 代码审查：定期检查属性声明（确保 strong 仅用于必要场景）和 block 使用。
• 工具辅助：
  • 启用 Xcode 的 Static Analyzer（Product > Analyze）检测潜在循环。
  • 运行 Instruments 的 Leaks 工具进行内存测试。
• ARC 注意事项：ARC 不能自动处理循环引用，开发者需主动管理。
  遵循这些方法，可显著减少内存泄漏风险，提升应用稳定性。如果您有具体代码案例，我可以进一步分析优化！