Block深入浅出

一、概述

闭包 = 一个函数『或指向函数的指针』 + 该函数执行的外部的上下文变量 『也就是自由变量』；Block是Objective-C对闭包的实现。
其中，Block：

• 可以嵌套定义，定义Block方法和定义函数方法相似
• Block可以定义在方法内部或外部
• 本质是对象，使代码高聚合
  使用clang将OC代码转换为C++文件查看block的方法：
• 在命令行输入代码clang -rewrite-objc 需要编译的oc文件.m
• 这时查看当前的文件夹里多了一个相同的名称的.cpp文件，在命令行输入open main.cpp查看文件

二、Block的定义与使用

1.无参数无返回值

void (^MyBlockOne)(void) = ^(void) {

};
MyBlockOne();//block调用

2.有参数无返回值

void (^MyBlockTwo)(int a) = ^(int a) {
    
};
MyBlockTwo(100);

3.有参数有返回值

int(^MyBlockThree)(int, int) = ^(int a, int b) {
    return a + b;
};
MyBlockThree(12, 56);

4.无参数，有返回值

int (^MyBlockFour)(void) = ^{
    return 45;
};
MyBlockFour();

5.实际开发中常用typedef定义Block
例如，用typedef定义一个block：

typedef int (^MyBlock)(int, int);

这时，MyBlock就成为了一种Block类型，定义类的属性时可以这样：

@property (nonatomic, copy) MyBlock myBlockOne;

使用时：

self.myBlockOne = ^int (int, int) {
    //TODO
}

三、Block与外界变量

截获自动变量（局部变量）值
1.默认情况
对于block外的变量引用，block默认是将其复制到其数据结构中来实现访问的。也就是说block的自动变量截获只针对block内部使用的自动变量，不使用则不截获，因为截获的自动变量会存储于block的结构体内部，会导致block体积变大，特别需要注意的是默认情况下block只能访问不能修改局部变量的值。

WX20190708-145855.png

int age = 10;
myBlock block = ^{
    NSLog(@"age = %d", age);
};
age = 18;
block();
//输出结果：
//age = 10;

2.__block修饰的外部变量
对于用__block修饰的外部变量引用，block是复制其引用地址来实现访问的。block可以修改__block修饰的外部变量的值

WX20190708-150145.png

__block int age = 10;
myBlock block = ^{
    NSLog(@"age = %d", age);
};
age = 18;
block();
//输出为：
//age = 18

为什么使用__block修饰的外部变量的值就可以被block修改呢？
我们使用clang将oc代码转换为c++文件：

clang -rewrite-objc 源代码文件名

便可解开其真正面纱：

__block int val = 10;
//转换成
__Block_byref_val_0 val = {
    0,
    &val,
    0,
    &sizeof(__Block_byref_val_0),
    10
};

会发现一个局部变量加上__block修饰符后竟然跟block一样变成了一个__Block_byref_val_0结构体类型的自动变量实例。
此时我们在block内部访问val变量则需要通过一个叫__forwarding的成员变量来间接访问val变量

四、Block的copy操作

1.Block的存储域及copy操作
在开始研究Block的copy操作之前，先来思考一下：Block是存储在栈上还是堆上呢？
我们先来看看一个由C/C++/OBJC编译的程序占用内存的结构：

WX20190708-151828.png

其实，block有三种类型：

• 全局块（_NSConcreteGlobalBlock）
• 栈块（_NSConcreteStackBlock）
• 堆块（_NSConcreteMallocBlock）

这三种block各自的存储域如下图：

WX20190708-153416.png

• 全局块存在于全局内存中，相当于单利
• 栈块存在于栈内存中，超出其作用域马上被销毁
• 堆块存在于堆内存中，是一个带引用计数的对象，需要自行管理其内存

简而言之，存储在栈中的Block就是栈块、存储在堆中的就是堆块、既不在栈中也不在堆中的块就是全局块。
遇到一个Block，我们怎么确定这个Block的存储位置呢？
1.Block不访问外界变量（包括栈中和堆中的变量），Block既不在栈又不在堆中，在代码段中，ARC和MRC下都是如此，此时为全局块。
2.Block访问外界变量
MRC环境下：访问外界变量的Block默认存储在栈中。
ARC环境下：访问外界变量的Block默认存储在堆中，（实际是放在栈区的，然后ARC情况下自动又拷贝到堆区），自动释放
ARC环境下，访问外界变量的Block为什么要自动从栈区拷贝到堆区呢？
栈上的Block，如果其所属的变量作用域结束，该Block就被废弃，如同一般的自动变量，当然Block中的__block变量也同时被废弃，如下图：

WX20190708-154925.png

为了解决栈块在其变量作用域结束之后被废弃（释放）的问题，我们需要把Block复制到堆中，延长其生命周期。开启ARC时，大多数情况下编译器会恰当地进行判断是否有需要将Block从栈复制到堆，如果有，自动生成将Block从栈上复制到堆上的代码。Block的复制操作执行的是copy实例方法。Block只要调用了copy方法，栈块就会变成堆块。
如下图：

WX20190708-155228.png

例如下面一个返回值为Block类型的函数：

typedef int (^blk_t) (int);
blk_t func(int rate) {
    return ^(int count) {
        return rate * count;
    };
}

分析可知：上面的函数返回的Block是配置在栈上的，所以返回函数调用方式时，Block变量作用域就结束了，Block会被废弃，但在ARC有效，这种情况编译器会自动完成复制。
在非ARC环境下，则需要开发者调用copy方法手动复制，由于开发中几乎都是ARC，所以手动复制内容不再过多研究。
将Block从栈上复制到堆上相当消耗CPU，所以当Block设置在栈上也能够使用时，就不要复制了，因为此时的复制只是在浪费CPU资源。
Block的复制操作执行的是copy实例方法。不同类型的Block使用copy方法的效果如下表：

WX20190708-160113.png

根据表得知，Block在堆中copy会造成引用计数增加，这与其它Objective-C对象是一样的。虽然Block在栈中也是以对象身份存在，但是栈块没有引用计数，因为不需要，我们都知道栈区的内存由编译器自动释放。
不管Block存储域在何处，用copy方法复制都不会引起任何问题，在不确定时调用copy方法即可。
在ARC有效时，多次调用copy方法完全没有问题：

blk = [[[[blk copy] copy] copy] copy];
//经过多次复制，变量blk仍然持有Block的强引用，该Block不会被废弃

2.__block变量与__forwarding
在copy操作之后，既然__block变量也被copy到堆上去了，那么访问该变量是访问栈上的还是堆上的呢？

WX20190708-160903.png

通过__forwarding，无论是在block中还是block外访问__block变量，也不管该变量在栈上或堆上，都能顺利地访问同一个__block变量。

五、防止Block循环引用

Block循环引用的情况：
某个类将block作为自己的属性变量，然后该类在block的方法体里面又使用了该类本身，如下：

self.someBlock = ^(Type var){
    [self dosomething];
};

解决办法：
1.ARC下：使用__weak

__weak typeof(self) weakSelf = self;
self.someBlock = ^(Type var) {
    [weakSelf dosomething];
};

2.MRC下：使用__block

__block typeof(self) blockSelf = self;
self.someBlock = ^(Type var) {
    [blockSelf dosomething];
};

值得注意的是，在ARC下，使用__block也有可能带来循环引用的问题，如下：

//循环引用 self -> _attributBlock -> tmp -> self
typedef void (^Block)();
@interface TestObj : NSObject
{
    Block _attributBlock;
}
@end

@implementation TestObj
- (id)init {
    self = [super init];
    __block id tmp = self;
    self.attributBlock = ^{
        NSLog(@"Self = %@", tmp);
        tmp = nil;
    };
    return self;
}

- (void)execBlock {
    self.attributBlock(); 
}
@end

//使用类
id obj = [[TestObj alloc] init];
[obj execBlock];//如果不调用此方法，tmp永远不会置nil，内存泄露会一直在

六、Block的使用示例

1.Block作为变量（Xcode快捷键：inlineBlock）

//定义一个Block变量sum
int (^sum) (int, int);
//给Block变量赋值
//一般返回值省略：sum = ^(int a, int b)...
sum = ^int (int a, int b) {
    return a + b;
};//赋值语句最后有分号
int a = sum(10, 20);//调用Block变量

2.Block作为属性（Xcode快捷键：typedefBlock）

//1.给Calculate类型 sum变量 赋值『下定义』
typedef int (^Calculate)(int, int);//calculate就是类型名
Calculate sum = ^(int a, int b) {
     return a + b;
 };
int a = sum(10, 20);//调用sum变量

//2.作为对象的属性声明，copy后block会转义到堆中和对象一起
@property (nonatomic, copy) Calculate sum;    //使用typedef
@property (nonatomic, copy) int (^sum)(int, int);    //不使用typedef

//声明，类外
self.sum = ^(int a, int b) {
    return a + b;
};

//调用，类内
int a = self.sum(10, 20);

3.作为OC中的方法参数

//无参数传递的Block
- (CGFloat)testTimeConsume:(void (^)())middleBlock {
    //执行前记录下当前时间
    CFTimeInterval startTime = CACurrentMediaTime();
    middleBlock();
    //执行后记录下当前的时间
    CFTimeInterval endTime = CACurrentMediaTime();
    return endTime - startTime;
}

//调用
[self testTimeConsume:^{
    //放入block中的代码
}];

//有参数传递的Block
- (CGFloat)testTimeConsume:(void (^)(NSString *name))middleBlock {
    //执行前记录下当前时间
    CFTimeInterval startTime = CACurrentMediaTime();
    middleBlock(name);
    //执行后记录下当前的时间
    CFTimeInterval endTime = CACurrentMediaTime();
    return endTime - startTime;
}

//调用
[self testTimeConsume:^(NSString *name) {
    //放入block中的代码，可以使用参数name 
    //参数name是实现代码中传入的，在调用时只能使用，不能传值
}];

4.Block回调
Block回调是关于Block最常用的内容，比如网络加载，我们可以用Block实现下载成功与失败的反馈。开发者在block没发布前，实现回调基本都是通过代理的方式进行的，比如负责网络请求的原生类NSURLConnection类，通过多个协议方法实现请求中的事件处理。而在最新的环境下，使用的NSURLSession已经采用block的方式处理任务请求了。各种第三方网络请求框架也都在使用block进行回调处理，这种转变很大一部分原因在于block使用简单，逻辑氢气，灵活等原因。
为了加深理解，再来一个简单的小例子：
A，B两个界面，A界面中有一个label，一个buttonA。点击buttonA进入B界面，B界面中有一个UITextfield和一个buttonB，点击buttonB退出B界面并将B界面中UITextfield的值传到A界面中的label。
A界面中，也就是ViewController类中：

//关键demo
- (IBAction)buttonAction {
    MyFirstViewController *myVC = [[MyFirstViewController alloc]] init];
    [self presentViewController:myVC animated:YES completion:^{
    }];
    __weak typeof(self) weakSelf = self;//防止循环引用
    //用属性定义的注意：这里属性是不会自动补全的，方法就会自动补全
    [myVC setBlock:^(NSString *string) {
        weakSelf.labelA.text = string;
    }];
}

在B界面中，也就是MyFirstViewController类中.m文件：

- (IBAction)buttonAction {
    [self dismissViewControllerAnimated:YES completion:^{
    }];
    self.block(_myTextfield.text);
}

.h文件

#import 
//typedef定义一下block，为了更好实用
typedef void(^MyBlock)(NSString *string);
@interface MyFirstViewController : UIViewController
@property (nonatomic, copy) MyBlock block;
@end

看了以上两个Block回调示例，是不是感觉比delegate清爽了不少？