捧着一杯枸杞茶1. Block 内存布局概述
在 Objective-C 和 Swift 混编开发中，Block 是一个非常重要的概念。它本质上是一个匿名函数，可以捕获上下文中的变量，并在需要的时候执行。理解 Block 的内存布局对于编写高效、安全的代码至关重要，特别是在涉及内存管理和性能优化的场景下。
Block 的内存布局决定了它如何存储捕获的变量、如何管理生命周期，以及如何与 ARC 交互。一个典型的 Block 在内存中由多个部分组成，包括函数指针、描述信息和捕获的变量等。这些组成部分的排列方式和访问机制直接影响 Block 的行为和性能。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. Block 的基本结构
2.1 Block 的底层表示
在底层，Block 是通过一个结构体来实现的。这个结构体包含了 Block 执行所需的所有信息。以下是一个简化版的 Block 结构体定义：
c复制struct Block_layout {
void *isa;
int flags;
int reserved;
void (*invoke)(void *, ...);
struct Block_descriptor *descriptor;
// 捕获的变量会跟随在这里
};
isa指针指向 Block 的类，表明这是一个什么类型的对象（在 Objective-C 中，Block 也是对象）flags存储了 Block 的各种标志位信息reserved是保留字段invoke是函数指针，指向 Block 的实际执行代码descriptor指向描述 Block 的附加信息的结构体
2.2 Block 的类型
Block 有三种类型，它们的内存管理方式有所不同：
-
全局 Block（NSGlobalBlock）：不捕获任何外部变量的 Block。它在编译期就已经确定，存储在全局数据区，生命周期与程序相同。
-
栈 Block（NSStackBlock）：捕获了外部变量，但还未被拷贝到堆上的 Block。它的生命周期与创建它的栈帧相同，当栈帧销毁时，Block 也会被销毁。
-
堆 Block（NSMallocBlock）：栈 Block 被拷贝到堆上后形成的 Block。它由 ARC 管理生命周期，可以安全地在多个执行上下文之间传递。
3. Block 的内存布局细节
3.1 捕获变量的存储方式
Block 捕获变量的方式取决于变量的类型和修饰符：
- 基本数据类型：值会被直接拷贝到 Block 结构体中
- 对象类型：
- 默认是强引用（在 ARC 下）
- 使用
__weak修饰符可以避免循环引用 - 使用
__block修饰符允许在 Block 内部修改外部变量
- C 数组：需要特别注意，因为 Block 不能直接捕获 C 数组
objectivec复制int a = 10;
__block int b = 20;
NSObject *obj = [NSObject new];
__weak NSObject *weakObj = obj;
void (^block)(void) = ^{
NSLog(@"a=%d, b=%d, obj=%@, weakObj=%@", a, b, obj, weakObj);
};
在这个例子中：
a的值会被直接拷贝到 Block 结构体中b会被特殊处理，允许在 Block 内部修改obj会被强引用weakObj会被弱引用
3.2 Block 描述符
Block_descriptor 结构体包含了 Block 的额外信息：
c复制struct Block_descriptor {
unsigned long int reserved;
unsigned long int size;
void (*copy)(void *dst, void *src);
void (*dispose)(void *);
};
size表示 Block 结构体的总大小copy和dispose是辅助函数，用于管理捕获对象的内存- 当 Block 被拷贝到堆上时，会调用
copy函数 - 当 Block 被释放时，会调用
dispose函数
- 当 Block 被拷贝到堆上时，会调用
4. Block 的内存管理
4.1 从栈到堆的拷贝
栈 Block 在被需要长期持有时（比如被赋值给 strong 属性、作为返回值、被 GCD 使用等），会自动被拷贝到堆上，变成堆 Block。这个过程包括：
- 在堆上分配新的内存空间
- 复制栈 Block 的内容到堆上
- 对捕获的对象调用 retain（如果是强引用）
- 设置 isa 指针为 NSMallocBlock
4.2 ARC 下的 Block 内存管理
在 ARC 环境下，大多数内存管理都是自动的，但仍有需要注意的地方：
- 将 Block 赋值给 strong 属性或变量时，会自动执行 copy 操作
- 在 MRC 环境下，需要手动调用 copy 和 release
- 避免循环引用：当 Block 捕获 self，而 self 又强引用这个 Block 时，就会形成循环引用
objectivec复制// 循环引用的例子
self.completionBlock = ^{
[self doSomething]; // Block 捕获了 self，而 self 又持有 Block
};
// 解决方案：使用 weak-strong dance
__weak typeof(self) weakSelf = self;
self.completionBlock = ^{
__strong typeof(weakSelf) strongSelf = weakSelf;
[strongSelf doSomething];
};
5. Block 的进阶话题
5.1 __block 修饰符的原理
__block 修饰符实际上是将变量包装到了一个辅助结构体中：
c复制struct __Block_byref_b_0 {
void *__isa;
__Block_byref_b_0 *__forwarding;
int __flags;
int __size;
int b;
};
当变量被 __block 修饰时：
- 编译器会创建一个这样的结构体
- 结构体的
__forwarding指针最初指向栈上的结构体实例 - 当 Block 被拷贝到堆上时，
__forwarding会被更新为指向堆上的副本 - 这样无论在栈 Block 还是堆 Block 中访问变量，都能找到正确的存储位置
5.2 Block 的性能考量
- 创建开销：Block 的创建比普通函数调用开销大，特别是在捕获多个变量时
- 调用开销：Block 的调用比直接函数调用稍慢，因为多了一层间接寻址
- 内存占用：每个 Block 都会占用额外的内存来存储捕获的变量和元数据
优化建议：
- 避免在频繁执行的循环中创建 Block
- 对于简单的操作，考虑使用函数指针代替 Block
- 尽量减少 Block 捕获的变量数量
6. 实际案例分析
6.1 多线程中的 Block 使用
在 GCD 中，Block 被广泛使用。GCD 会自动将 Block 拷贝到堆上，因此不需要担心生命周期问题：
objectivec复制dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 这个 Block 会被 GCD 自动拷贝到堆上
[self doBackgroundWork];
});
6.2 Block 作为回调
Block 常被用作回调，比 delegate 模式更灵活：
objectivec复制- (void)fetchDataWithCompletion:(void (^)(NSData *data, NSError *error))completion {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSData *data = // 获取数据
NSError *error = // 可能的错误
dispatch_async(dispatch_get_main_queue(), ^{
if (completion) {
completion(data, error);
}
});
});
}
6.3 Block 的内存问题调试
使用 Instruments 的 Allocations 工具可以跟踪 Block 的内存分配情况。特别关注：
- Block 是否被意外地多次拷贝
- 是否有 Block 没有被正确释放
- 是否有循环引用导致的内存泄漏
7. Block 与其他语言的闭包比较
7.1 与 Swift 闭包的比较
Swift 的闭包与 Objective-C Block 类似，但有几点不同：
- Swift 闭包默认是非逃逸的（noescape），除非显式标记为 @escaping
- Swift 闭包捕获列表更明确，可以精确控制捕获方式
- Swift 闭包对值类型的捕获行为不同（会捕获整个值）
7.2 与 C++ lambda 的比较
C++ lambda 也类似于 Block，但：
- C++ lambda 不自动管理内存，需要手动控制生命周期
- C++ lambda 的捕获列表更灵活，可以精确控制捕获哪些变量
- C++ lambda 可以修改捕获的值（类似于 __block）
8. 最佳实践与常见陷阱
8.1 Block 使用的最佳实践
- 明确 Block 的所有权：知道谁负责持有和释放 Block
- 避免循环引用：使用 weak-strong dance
- 考虑性能：避免在性能关键路径上频繁创建 Block
- 保持简洁：复杂的 Block 逻辑考虑提取为独立方法
8.2 常见陷阱
-
在 Block 内意外强引用 self：
objectivec复制[self doSomethingWithCompletion:^{ [self finishWork]; // 意外强引用 }]; -
误以为栈 Block 可以长期使用：
objectivec复制void (^block)(void); if (condition) { int value = 42; block = ^{ NSLog(@"%d", value); }; // 栈 Block，离开作用域后无效 } block(); // 崩溃！ -
忽略 Block 的返回值：
objectivec复制int (^block)(void) = ^{ return 42; }; block(); // 返回值被忽略 -
在多线程中错误共享 Block：
objectivec复制__block int counter = 0; void (^block)(void) = ^{ counter++; }; // 多个线程同时执行这个 Block 会导致数据竞争 dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t i) { block(); });
9. Block 的调试技巧
9.1 使用 LLDB 调试 Block
在 LLDB 中，可以检查 Block 的信息：
code复制(lldb) p block
(void (^)(void)) $0 = 0x0000600001e4c0a0
(lldb) p (struct Block_layout *)0x0000600001e4c0a0
(struct Block_layout *) $1 = 0x0000600001e4c0a0
(lldb) p *$1
(struct Block_layout) $2 = {
isa = 0x000000010f5a21e0
flags = -989855744
reserved = 0
invoke = 0x000000010f3a5b40 (Example`__ViewController_viewDidLoad_block_invoke at ViewController.m:23)
descriptor = 0x000000010f5a2220
}
9.2 使用编译器标志
可以添加编译器标志来获取更多 Block 相关的信息：
code复制-fdump-struct-layouts // 输出结构体布局
9.3 运行时检查
可以使用 object_getClass() 来检查 Block 的类型：
objectivec复制Class blockClass = object_getClass(block);
if (blockClass == NSClassFromString(@"__NSGlobalBlock__")) {
NSLog(@"Global block");
} else if (blockClass == NSClassFromString(@"__NSStackBlock__")) {
NSLog(@"Stack block");
} else if (blockClass == NSClassFromString(@"__NSMallocBlock__")) {
NSLog(@"Heap block");
}
10. Block 的高级应用
10.1 实现高阶函数
利用 Block 可以实现类似函数式编程的高阶函数：
objectivec复制- (NSArray *)map:(NSArray *)array withBlock:(id (^)(id))block {
NSMutableArray *result = [NSMutableArray arrayWithCapacity:array.count];
for (id obj in array) {
[result addObject:block(obj) ?: [NSNull null]];
}
return result;
}
// 使用示例
NSArray *numbers = @[@1, @2, @3];
NSArray *squares = [self map:numbers withBlock:^id(NSNumber *num) {
return @(num.integerValue * num.integerValue);
}];
10.2 实现链式调用
Block 可以用来创建流畅的 API：
objectivec复制@interface Calculator : NSObject
@property (nonatomic, assign) NSInteger result;
- (Calculator *(^)(NSInteger))add;
- (Calculator *(^)(NSInteger))multiply;
@end
@implementation Calculator
- (Calculator *(^)(NSInteger))add {
return ^Calculator *(NSInteger value) {
self.result += value;
return self;
};
}
- (Calculator *(^)(NSInteger))multiply {
return ^Calculator *(NSInteger value) {
self.result *= value;
return self;
};
}
@end
// 使用示例
Calculator *calc = [Calculator new];
calc.add(5).multiply(3).add(10);
NSLog(@"Result: %ld", (long)calc.result); // 输出 25
10.3 实现异步流水线
Block 可以很好地组织异步操作：
objectivec复制- (void)performAsyncOperations {
[self asyncOperation1WithCompletion:^(id result1, NSError *error1) {
if (error1) {
[self handleError:error1];
return;
}
[self asyncOperation2WithInput:result1 completion:^(id result2, NSError *error2) {
if (error2) {
[self handleError:error2];
return;
}
[self asyncOperation3WithInput:result2 completion:^(id result3, NSError *error3) {
if (error3) {
[self handleError:error3];
return;
}
[self finalizeWithResult:result3];
}];
}];
}];
}
11. Block 的替代方案
虽然 Block 非常强大，但在某些情况下，可以考虑其他替代方案：
-
Delegate 模式：
- 更适合长期存在的、复杂的回调关系
- 可以定义明确的协议，更易于文档化和类型检查
-
NotificationCenter：
- 适合一对多的通知场景
- 发送者和接收者不需要直接知道对方
-
Promise/Future：
- 提供更强大的异步编程模型
- 可以链式组合多个异步操作
- 有第三方库如 PromiseKit 可用
-
RxSwift/RAC：
- 响应式编程框架
- 提供更强大的数据流组合能力
选择依据：
- 简单回调：Block
- 复杂关系：Delegate
- 一对多通知：Notification
- 复杂异步：Promise/Rx
12. Block 在 Swift 中的使用
虽然本文主要讨论 Objective-C Block，但在 Swift 中也有类似的闭包概念：
-
语法差异：
- Objective-C:
^{ NSLog(@"Hello"); } - Swift:
{ print("Hello") }
- Objective-C:
-
捕获语义：
- Swift 闭包默认捕获不可变副本
- 需要显式声明
inout才能修改外部变量
-
逃逸与非逃逸：
- Swift 闭包默认是非逃逸的
- 需要显式标记
@escaping如果闭包会逃逸当前作用域
-
自动闭包：
- Swift 支持
@autoclosure自动将表达式包装为闭包
- Swift 支持
swift复制// Swift 闭包示例
func doAsyncWork(completion: @escaping (Result<Data, Error>) -> Void) {
DispatchQueue.global().async {
let result = Result { try fetchData() }
DispatchQueue.main.async {
completion(result)
}
}
}
13. Block 相关的编译器优化
Clang 编译器会对 Block 进行多种优化：
- 内联优化：简单的 Block 可能会被内联展开
- 捕获优化：未使用的捕获变量可能会被优化掉
- 栈提升：某些情况下，编译器会直接将 Block 分配到堆上
- TCO（尾调用优化）：在 Block 尾部调用函数时可能进行优化
可以通过编译器标志控制优化级别：
code复制-O0 // 无优化（便于调试）
-Os // 优化大小
-O3 // 最大优化
14. Block 与内存安全的注意事项
-
野指针风险：
- 当 Block 捕获的指针指向的对象已被释放时，访问该指针会导致崩溃
- 使用
__weak或__unsafe_unretained时需要特别小心
-
线程安全：
- 多个线程同时执行同一个 Block 时，需要确保捕获变量的线程安全
- 特别是
__block变量，可能需要额外的同步机制
-
栈溢出：
- 递归调用 Block 可能导致栈溢出
- 深度递归应考虑使用迭代或显式堆栈
15. Block 的性能测试与基准
可以使用 XCTest 的 measureBlock: 方法测试 Block 的性能：
objectivec复制- (void)testBlockPerformance {
[self measureBlock:^{
// 测试 Block 创建和调用的性能
void (^block)(void) = ^{ /* 一些操作 */ };
for (int i = 0; i < 10000; i++) {
block();
}
}];
}
一些典型数据（仅供参考）：
- 简单 Block 创建：约 10-50 ns
- Block 调用：比直接函数调用慢 2-5 倍
- 捕获多个变量的 Block 创建开销更大
16. Block 的 ABI 稳定性
Block 的 ABI（应用二进制接口）在苹果平台上是稳定的，这意味着：
- 不同版本的编译器生成的 Block 代码可以互相兼容
- 系统库提供的 Block API 可以安全使用
- 第三方库提供的 Block 回调可以正常工作
但是需要注意：
- 不同平台（macOS/iOS/watchOS/tvOS）可能有细微差异
- 极少数情况下，ABI 可能会有不兼容的变更（通常会提供迁移期）
17. Block 的调试符号
为了在调试时获得更好的 Block 相关信息，可以：
- 确保开启调试符号生成（DEBUG_INFORMATION_FORMAT = dwarf-with-dsym）
- 使用
-fblocks编译器标志 - 在 LLDB 中使用
image lookup命令查找 Block 相关信息
code复制(lldb) image lookup -r -n __block_invoke
18. Block 在混合编程中的使用
在 Objective-C 和 C++ 混合编程时（Objective-C++），Block 的使用需要注意：
- C++ 对象被 Block 捕获时，需要确保正确的构造和析构
- 可能需要
__block修饰符来捕获 C++ 对象 - 避免在 Block 中捕获
this指针，可能导致悬垂指针
objectivec复制// Objective-C++ 示例
std::vector<int> vec = {1, 2, 3};
void (^block)(void) = ^{
// 访问 C++ 对象
for (int i : vec) {
std::cout << i << std::endl;
}
};
19. Block 的替代实现
虽然苹果的 Block 实现是最常用的，但也有其他实现：
- libdispatch：GCD 提供的 Block 实现
- PLBlocks：一个可移植的 Block 运行时
- C++ lambda：在 Objective-C++ 中可以作为替代
这些替代实现可能在内存管理、性能特性上有细微差别。
20. Block 的未来发展
随着 Swift 的普及，Objective-C Block 的使用可能会减少，但在以下场景仍然重要：
- 维护遗留 Objective-C 代码
- 与 C/C++ 交互的边界
- 需要极致性能控制的场景
- 某些系统 API 仍然基于 Block
Swift 的闭包虽然更现代，但底层实现仍然借鉴了 Block 的许多概念。理解 Block 的内存布局有助于更好地使用 Swift 闭包。