block基础及在网络请求和block嵌套中的使用

在网络请求的开发中，一般会将请求结果封装成一个 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 在使用前均进行判空处理