在网络请求的开发中，一般会将请求结果封装成一个 block 回调。block 中对 self 的使用一般都会将 self 在 block 外先 __weak 一下，再在 block 内部 __strong 一下。如此操作可以处理大部分场景，不至于产生内存泄露。
在这篇文章里，主要探讨两种情形下的 block 使用 (完整 Demo 点这里) ：
- 网络请求一般采用异步操作，在页面被关闭后，我们希望页面所占用的内存可以尽快的释放，即网络响应回调后不继续执行回调里的代码。
- block 内部嵌套 block 如何使用 self。
block 基础
关于 block 的介绍很多，这里只会简单介绍。
1. block 的循环引用
- (void)test1 {
self.testBlock = ^{
self.view.backgroundColor = [UIColor lightGrayColor];
};
self.testBlock();
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[self dismissViewControllerAnimated:NO completion:nil];
});
}
在控制器中强持有一个 block ，在 block 内部又使用了 self ，这就造成了一个简单的循环引用，导致 self 的引用计数始终大于0，self 的内存不会被释放，也就造成了内存泄露。
2. block 循环引用的破解方法
通用的破解循环引用的方法是使用 __weak 将 self 弱引用，在 block 内部使用 weakSelf , 即：
__weak typeof(self) weakSelf = self;
self.testBlock = ^{
weakSelf.view.backgroundColor = [UIColor lightGrayColor];
};
__weak 的作用是生成一个指向原对象内存地址的对象，但不使原对象的引用计数 +1，从而不影响原对象的释放。
3. block 弱引用中的注意事项
由于通过 __weak 解除了对 self 的强引用，所以 self 的内存随时可能因为引用计数为0，而被系统回收，从而 block 内部的 weakSelf 随时可能为 nil 。例如：
- (void)test2 {
__weak typeof(self) weakSelf = self;
self.testBlock = ^{
weakSelf.view.backgroundColor = [UIColor lightGrayColor];
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
if (!weakSelf) {
NSLog(@"test2 weakSelf 被系统回收了");
} else {
NSLog(@"test2 weakSelf 我是打不死的小强");
}
});
};
self.testBlock();
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[self dismissViewControllerAnimated:NO completion:nil];
});
}
在 block 内经过5秒的延时后 weakSelf 此时就为 nil 了。
为了解决这个问题，通用的方案是在 block 内部用 __strong 将 weakSelf 强引用一下，然后在 block 内部使用这个 strongSelf 。即：
self.testBlock = ^{
__strong typeof(weakSelf) strongSelf = weakSelf;
strongSelf.view.backgroundColor = [UIColor lightGrayColor];
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
if (!strongSelf) {
NSLog(@"test2 strongSelf 被系统回收了");
} else {
NSLog(@"test2 strongSelf 我是打不死的小强");
}
});
};
__strong 的作用是生成一个指向原对象内存地址的对象，使原对象的引用计数 +1。由于生成的 strongSelf 的作用域仅限于这个 block 内部，所以 block 内部的代码执行完后，其引用计数就会被 -1，从而不影响原对象的释放。在 block 内经过5秒延时后， strongSelf 不为 nil 。
block 在网络请求中的应用
以下例子中，用 dispatch_after 模拟网络请求
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{});
1. 网络请求回调中不使用 __weak
- (void)test3 {
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_global_queue(0,0), ^{
if (!self) {
NSLog(@"test3 self 被系统回收了");
} else {
NSLog(@"test3 self 我是打不死的小强");
}
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[self dismissViewControllerAnimated:NO completion:nil];
});
}
log 输出结果：
test3 self 我是打不死的小强
dealloc ======
log 的分析：
block 回调 执行完毕后，控制器才会执行 dealloc 方法
2. 网络请求回调中使用 __weak
- (void)test4 {
__weak typeof(self) weakSelf = self;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{
__strong typeof(weakSelf) strongSelf = weakSelf;
if (!strongSelf) {
NSLog(@"test4 strongSelf 被系统回收了");
} else {
NSLog(@"test4 strongSelf 我是打不死的小强");
}
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[self dismissViewControllerAnimated:NO completion:nil];
});
}
log 输出结果：
dealloc ======
test4 strongSelf 被系统回收了
log 分析：
控制器先执行 dealloc 方法，block 回调时 self 的内存已经被系统回收了
网络请求中针对 block 的使用结论和建议
根据 test3 和 test4 两个 log 的分析，我们得出结论和建议：
- 网络请求的 block 回调中的 self 会强引用 self ，在block中的代码执行完毕后，对 self 的强引用才会解除
- 在 block 外部对 self 使用 __weak ，在 block 内部的 weakSelf ，不会强引用 self ，不会影响 self 的释放
- 在网络请求中，由于当前页面随时可能会被关闭，为了及时释放页面所占用的内存，建议：
1. 使用 __weak 、__strong 的搭配
2. 在block 内部先对 strongSelf ,进行判空处理
block 内部嵌套 block
1. 被嵌套的 block 不使用 weak - strong 搭配
- (void)test5 {
__weak typeof(self) weakSelf = self;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.5 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{
__strong typeof(weakSelf) strongSelf = weakSelf;
if (!strongSelf) {
NSLog(@"test5 strongSelf 被系统回收了");
} else {
NSLog(@"test5 strongSelf 我是打不死的小强");
}
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{
if (!strongSelf) {
NSLog(@"test5 dispatch_after strongSelf 被系统回收了");
} else {
NSLog(@"test5 dispatch_after strongSelf 我是打不死的小强");
}
});
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[self dismissViewControllerAnimated:NO completion:nil];
});
}
输出 log 如下：
test5 strongSelf 我是打不死的小强
test5 dispatch_after strongSelf 我是打不死的小强
dealloc ======
log 分析：
1. 外层的 block 回调时，页面尚未 dismiss ，此时 strongSelf 指向的内存地址依然存在
2. 由于 strongSelf 对 self 强引用的关系，外层的 block 回调执行完后，才会解除对 self 的强引用
3. 由于内层的 block 回调中保存着 strongSelf ，因此，内层 block 的代码执行完，外层 block 回调才算执行完
2. 被嵌套的 block 也使用 weak - strong 搭配
- (void)test7 {
__weak typeof(self) weakSelf = self;
dispatch_async(dispatch_get_main_queue(), ^{
__strong typeof(weakSelf) strongSelf = weakSelf;
if (!strongSelf) {
NSLog(@"test7 strongSelf 被系统回收了");
} else {
NSLog(@"test7 strongSelf 我是打不死的小强");
}
__weak typeof(self) weakSelf = strongSelf;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{
__strong typeof(self) strongSelf = weakSelf;
if (!strongSelf) {
NSLog(@"test7 dispatch_after strongSelf 被系统回收了");
} else {
NSLog(@"test7 dispatch_after strongSelf 我是打不死的小强");
}
});
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[self dismissViewControllerAnimated:NO completion:nil];
});
}
输出 log 如下：
test7 strongSelf 我是打不死的小强
dealloc ======
test7 dispatch_after strongSelf 被系统回收了
log 分析：
1. 外层的 block 回调时，页面尚未 dismiss ，此时 strongSelf 指向的内存地址依然存在
2. 由于 strongSelf 对 self 强引用的关系，外层的 block 回调执行完后，才会解除对 self 的强引用
3. 由于内层的 block 回调中保存着一个弱引用 strongSelf 的 weakSelf 对象，因此，weakSelf 不会影响 strongSelf 的内存释放，即：strongSelf 会在内层 block 回调执行前释放。待内层 block 回调执行时，weakSelf 指向的 strongSelf 的内存已被释放，weakSelf 置为 nil 了
block 嵌套结论与建议
根据 test5 、test7 的 log 分析，可以得出以下结论和建议：
- block 嵌套，仅对外层 block 使用 weak - strong 搭配，不会造成内存泄露，待内层block 执行完毕后，strongSelf 内存就会被释放
- 建议：为了及时释放占用的内存，建议在内外层 block 均使用 weak - strong 搭配，并对 block 内部的 strongSelf 在使用前均进行判空处理
网友评论