iOS开发之Block访问外部变量和循环引用问题

说起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 *)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的代码才会释放掉，即延迟释放。