说起Block在iOS开发中作用非常多，用处也非常广。但要用好Block，确保业务逻辑正常，并且内存管理不出问题，也是不简单的。本篇不再阐述Block的概念和语法用法，就Block访问外部变量和循环引用问题来介绍一下。
一、Block访问外部变量
我们先看一个block访问外部变量的例子：
int a = 10;
void(^myblock)(void) = ^(void) {
NSLog(@"a=%d",a);
};
a = 20;
myblock();
结果会发现打印的 a = 10
而且如果试图在block里修改a的值的话，Xcode就会报错，提示在a的定义前添加__block。
按提示修改代码后发现：
__block int a = 10;
void(^myblock)(void) = ^(void) {
NSLog(@"a=%d",a);
};
a = 20;
myblock();
现在打印的就是 a = 20 了。
这是为什么呢？我们把mian.m文件编译成C++代码看一下到底是怎么实现的：
~/Desktop $ clang -rewrite-objc main.m
得到的main.cpp文件，其中main函数编译成了
int main(int argc, const char * argv[]) {
__attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 10};
void(*myblock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
(a.__forwarding->a) = 20;
((void (*)(__block_impl *))((__block_impl *)myblock)->FuncPtr)((__block_impl *)myblock);
return 0;
}
我们的block被编译成了一个结构体__main_block_impl_0，变量a作为了结构体的一个成员：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_a_0 *a; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
在main函数里我们可以看到，a传过来不只是a的值，而是(__Block_byref_a_0 *)&a，变量a的指针地址，所以我们就可以任意读写a的值了。
所以：
- block在访问外部变量时，会在block内部创建一个新的变量来保存这个外部变量，修改的是内部新变量的值，外部的变量不受影响；
- 当外部变量加了__block修饰，block保存了其指针引用，对指针变量的修改直接影响外部变量的值；
- 另外，静态变量、全局变量和全局静态变量，传入的就是地址值，可以直接被block修改。
二、Block循环引用问题
首先什么是循环引用呢？就是两个对象相互持有，在释放时，相互等待释放，造成死循环谁都释放不了，从而内存泄露。
即block作为self的属性时，又在block内部调用了self的属性和方法，block和self相互持有，那么两者的引用计数都至少是1，都不会被释放。
举个栗子：
//
// SecondViewController.m
// UITest
//
// Created by z on 2019/8/10.
// Copyright © 2019年 com.jzsec. All rights reserved.
//
#import "SecondViewController.h"
typedef void(^MyBlock)(int a);
@interface SecondViewController ()
@property (nonatomic,copy) MyBlock myblock;
@end
@implementation SecondViewController
- (void)viewDidLoad {
[super viewDidLoad];
SecondViewController *weakSelf = self;
self.myblock = ^(int a) {
[self doSomething];
};
}
-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
[self dismissViewControllerAnimated:YES completion:nil];
}
- (void)doSomething
{
NSLog(@"%s",__func__);
}
-(void)dealloc
{
NSLog(@"%s",__func__);
}
@end
这个地方还有第一个界面我就没写，很简单就是点击屏幕弹出这个SecondViewController，这个second点击界面就dismiss掉。但是运行后我们发现：
- second的dealloc方法并没有调用，说明第二个界面消失后并没有释放；
- 代码中[self doSomething];编译器给出警告：Capturing 'self' strongly in this block is likely to lead to a retain cycle，可以看出block里的变量默认是strong持有的，self又持有myBlock，所以提示循环引用了；
那么怎么避免造成循环引用呢？这里介绍三种方法：
- ARC下用__weak或__block;
- MRC下用__block;
- self作为block的参数传进去；
1、__weak
使用__weak定义一个弱引用的self临时变量，去掉强引用，这也是最常用的一种方法：
__weak typeof(self) weakSelf = self;
self.myblock = ^(int a) {
[weakSelf doSomething];
};
这样既去掉了编译器警告，而且还打印出了-[SecondViewController dealloc]，说明second已经释放掉，解决了循环引用。
2、__block
同样是声明一个临时self的变量，但是要记得在block里使用完这个临时变量时，把它置空，而且还要调用这个block：
__block SecondViewController *weakSelf = self;
self.myblock = ^(int a) {
[weakSelf doSomething];
weakSelf = nil;
};
self.myblock(1);
此时打印出：
2019-08-10 19:02:35.638863+0800 UITest[11066:395433] -[SecondViewController doSomething]
2019-08-10 19:02:36.792805+0800 UITest[11066:395433] -[SecondViewController dealloc]
说明second已经释放掉，解决了循环引用。
3、self作为block的参数
这个地方我们需要做一些改造，block重新定义一下：
typedef void(^MySecondBlock)(SecondViewController *vc);
... ...
@property (nonatomic,copy) MySecondBlock mySecondblock;
... ...
self.mySecondblock = ^(SecondViewController *vc) {
[vc doSomething];
};
self.mySecondblock(self);
此时运行后，依然能打印出：
2019-08-10 19:05:12.690490+0800 UITest[11160:399180] -[SecondViewController doSomething]
2019-08-10 19:05:14.369980+0800 UITest[11160:399180] -[SecondViewController dealloc]
说明second已经释放掉，解决了循环引用。
三、注意
1、block属性
block作为属性时，修饰符一定要用copy！在ARC下使用strong和copy效果一样，如果使用weak，那么这个block属性随时都有可能被释放掉，而无法调用。
2、不会造成循环引用的情况
那么只要是用到block，而不用上面三种方法就一定会造成循环引用吗？不是的，下面情况不会造成循环引用：
- 大部分GCD的block；
- Block作为临时变量；
3、避免self在block里提前释放
比如说self在block里延迟使用了，但是block走完之后weakSelf就不存在了，所以doSomething也就没有响应：
__weak typeof(self) weakSelf = self;
self.myblock = ^(int a) {
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[weakSelf doSomething];
});
};
Block执行过程中self对象被释放，用__strong修饰self，记得得调用了Block才起作用：
__weak typeof(self) weakSelf = self;
self.myblock = ^(int a) {
__strong typeof(self) strongSelf = weakSelf;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[strongSelf doSomething];
});
};
self.myblock(1);
此时依然打印出：
2019-08-10 19:18:34.574815+0800 UITest[11490:411849] -[SecondViewController doSomething]
2019-08-10 19:18:34.575089+0800 UITest[11490:411849] -[SecondViewController dealloc]
__strong typeof(self) strongSelf = weakSelf;
这句延长了weakSelf的生命周期，走完dispatch_after的代码才会释放掉，即延迟释放。
