文章目录
- 前言
- 2. Block
- 2.1 Block的使用规范
- 2.2 __block修饰符
- 2.3 Block的类型
- 2.4 Block的循环引用及解决
- 循环引用的场景引入
- 解决循环引用
- Block循环引用场景
- 2.5 Block的实现及其本质
- 2.5.1 初始化部分
- 2.5.2 调用部分
- 2.5.3 捕获变量
- Block本质
- 2.6 Block捕获变量 和 对象
- 2.7 Block的内存管理
- 3 Blcok的问题总结
- 1. block在修改NSMutableArray，需不需要添加__block？
- 2. __block如何达到修改内部的值？
- __Block_byref_age_0结构体
- __block 和Block 总结
- Block为什么用copy修饰
前言
博客以总结为主，随时更新
2. Block
带有自动变量（局部变量）的匿名函数
2.1 Block的使用规范
Block完整格式就是：变量声明 + 定义：
、
int(^sumBlk)(int num1, int num2) = ^int(int a, int b) {
return a + b;
};
Block变量类似于函数指针，
- 用途：自动变量（局部变量）
-
- 函数参数
-
- 静态变量
-
- 静态全局变量
-
- 全局变量
截获自动变量：带有自动变量值在Block中表现为“截获自动变量值”。
值得注意的点： 在现在的Blocks中，截获自动变量的方法并没有实现对C语言数组的截获
2.2 __block修饰符
block可以截获变量，但是在块里不能修改变量的值。
此时我们使用__block修饰符修饰变量，对需要在block内进行赋值的变量，使用修饰符修饰，保证可以对变量进行赋值。
// blk不允许修改截获变量的值，需要的时候加上__block修饰符即可
id tstArray = @[@"blk", @"不允许赋值", @"给截获的变量"];
__block id array = [[NSMutableArray alloc] init];
void (^blk)(void) = ^{
id obj = [[NSObject alloc] init];
// [array addObject:obj];
array = tstArray;
};
2.3 Block的类型
block分为全局 block、堆 block、栈 block
Block分类简单总结如下
- A、没有引用外部变量 —
block存放在全局区 - B、引用了外部变量----显式声明为
weak类型的block则存放在栈区，反之则是存在在堆区的，也就是说block是strong类型的。 NSGlobalBlock：
block内部没有引用外部变量，Block类型都是NSGlobalBlock类型，存储于全局数据区，由系统管理其内存，retain、copy、release操作都无效。如果访问了外部static或者 全局变量也是这种类型。NSStackBlock：
访问了外部变量，但没有强引用指向这个block，如直接打印出来的blockNSMallocBlock：
ARC环境下只要访问了外部变量，而且有强引用指向该block(或者作为函数返回值)就会自动将__NSStackBlock类型copy到堆上。
2.4 Block的循环引用及解决
循环引用的场景引入
循环引用就是对方面持有导致对象不能正常释放，会发生内存泄漏
在BLock里互相的强引用可能造成循环引用。
typedef void(^TBlock)(void);
@interface ViewController ()
@property (nonatomic, strong) TBlock block;
@property (nonatomic, copy) NSString *name;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// 循环引用
self.name = @"Hello";
self.block = ^(){
NSLog(@"%@", self.name);
};
self.block();
}
这里self持有了block，block持有了self，导致循环引用。
只要有一方没有进行强引用就可以解除循环引用
- (void)viewDidLoad {
[super viewDidLoad];
// 循环引用
self.name = @"Hello";
void(^block)(void);
block = ^(){
NSLog(@"%@", self.name);
};
block();
}
为什么这个案例就没有出现循环引用的状况呢？因为当前self，也就是ViewController并没有对block进行强持有，block的生命周期只在viewDidLoad方法内，viewDidLoad方法执行完，block就会释放。
解决循环引用
- __weak 因为__weak不会对对象的引用计数操作，也就是不会进行强引用.
- 上面的案例修改成weak来避免循环引用如下：
// 循环引用
self.name = @"Hello";
__weak typeof(self) weakSelf = self;
self.block = ^(){
NSLog(@"%@", weakSelf.name);
};
self.block();
此时self持有block，block弱引用self，弱引用会自动变为nil，强持有中断，所以不会引起循环引用。但该方法可能存在中途就释放掉的问题（手动延迟，可能需要调用self.name的时候name已经被释放了）如果self被销毁，那么block则无法获取name。
- 强弱共舞 ：
self.name = @"Hello";
__weak typeof(self) weakSelf = self;
self.block = ^(){
__strong __typeof(weakSelf)strongWeak = weakSelf;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", strongWeak.name);
});
};
self.block();
完全解决了以上self中途被释放的问题。
原理：在完成block中的操作之后，才调用了dealloc方法。添加strongWeak之后，持有关系为：self -> block -> strongWeak -> weakSelf -> self。
weakSelf被强引用了就不会自动释放，因为strongWeak只是一个临时变量，它的声明周期只在block内部，block执行完毕后，strongWeak就会释放，而弱引用weakSelf也会自动释放。
- 手动中断
self.name = @"Hello";
__block ViewController * ctrl = self;
self.block = ^(){
__strong __typeof(weakSelf)strongWeak = weakSelf;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", ctrl.name);
ctrl = nil;
});
};
self.block();
使用ctrl之后，持有关系为： self -> block -> ctrl -> self，ctrl在block使用完成后，被置空，至此block对self持有就解除，不构成循环引用
- 参数形式解决循环引用 block传参(指针拷贝)
// 循环引用
self.name = @"Hello";
self.block = ^(ViewController * ctrl){
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", ctrl.name);
});
};
self.block(self);
将self作为参数参入block中，进行指针拷贝，并没有对self进行持有
Block循环引用场景
静态变量持有
// staticSelf_定义：
static ViewController *staticSelf_;
- (void)blockWeak_static {
__weak typeof(self) weakSelf = self;
staticSelf_ = weakSelf;
}
weakSelf虽然是弱引用，但是staticSelf_静态变量，并对weakSelf进行了持有，staticSelf_释放不掉，所以weakSelf也释放不掉！导致循环引用！
2.5 Block的实现及其本质
BLock的实现是基于指针和函数指针，Block属性是指向结构体的指针
//这是正常的block流程
void(^myBlock)(void) = ^{
printf("myBlock");
};
myBlock();
得到Block的结构的源码定义（C++）：
void(*myBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
初始化定义部分block语法变成了：&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
调用block的过程变成了：(__block_impl *)myBlock)->FuncPtr
2.5.1 初始化部分
初始化部分就是Block结构体
//Block结构体
struct __main_block_impl_0 {
struct __block_impl impl;//impl:Block的实际函数指针，就是指向包含Block主体部分的__main_block_func_0结构体
struct __main_block_desc_0* Desc;//Desc指针，指向包含Block附加信息的__main_block_desc_0()结构体
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {//__main_block_impl_0:Block构造函数（可以看到都是对上方两个成员变量的赋值操作）
impl.isa = &_NSConcreteStackBlock; //
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
__main_block_impl_0结构体也就是Block结构体包含了三个部分：
- 成员变量impl
- 成员变量Desc指针
- __main_block_impl_0构造函数
struct __block_impl结构：包含Block实际函数指针的结构体
struct __block_impl {
void *isa;//用于保存Block结构体的实例指针
int Flags;//标志位
int Reserved;//今后版本升级所需的区域大小
void *FuncPtr;//函数指针
};
_block_impl包含了Block实际函数指针FuncPtr，FuncPtr指针指向Block的主体部分，也就是Block对应OC代码中的^{…}的部分- 还包含了标志位Flags，在实现block的内部操作时可能会用到
- 今后版本升级所需的区域大小
Reserved __block_impl结构体的实例指针isa
struct __main_block_desc_0结构：
Block附加信息结构体：包含今后版本升级所需区域的大小，Block的大小
static struct __main_block_desc_0 {
size_t reserved;//今后版本升级所需区域大小
size_t Block_size;//Block大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
Block构造函数__main_block_impl_0 ：
作为构造函数注意和Block结构体是一个名字。
负责初始化__main_block_impl_0结构体（也就是Block结构体struct __block_impl）的成员变量
//可以看到里面都是一些赋值操作
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
2.5.2 调用部分
- 函数原型
((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
逐步解析这段代码：
((__block_impl *)myBlock)->FuncPtr：这部分将myBlock转换为__block_impl指针类型，并访问FuncPtr成员。它获取了块实现内部存储的函数指针。((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)：在这里，函数指针被转换为一个函数类型，该函数接受一个类型为__block_impl*的参数，并返回void。它将函数指针转换为可以调用的实际函数类型。((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock)：最后，使用myBlock作为参数，调用了所得到的函数指针。它使用块实现对象调用该函数。
总结一下，该代码获取了存储在块实现内部的函数指针，然后调用该函数，将块实现对象自身作为参数传递进去。
2.5.3 捕获变量
Block捕获变量的时候 结构体里面多了 *NSObject obj; 以便Block去捕获。
Block本质
- 用一句话来说，Block是个对象（其内部第一个成员为isa指针）
- Block为什么出生就在栈上？
- 在他的初始化函数里面
impl.isa = &_NSConcreteStackBlock;
_NSConcreteStackBlock相当于该block实例的父类.将Block作为OC对象调用时，关于该类的信息放置于_NSConcretestackBlock中，这也证明了 block出生就是在栈上
2.6 Block捕获变量 和 对象
变量
- 全局变量： 不捕获
- 局部变量： 捕获值
- 静态全局变量： 不捕获
- 静态局部变量： 捕获指针
- const修饰的局部常量：捕获值
- const修饰的静态局部常量：捕获指针
对象
BLOCK 可以捕获对象，其中需要知道两个方法。
在捕获对象的时候代码出现了_main_block_copy_0 和 _main_block_depose_0。
__main_block_copy_0作用就是调用_Block_object_assign，相当于retain，将对象赋值在对象类型的结构体变量__main_block_impl_0中。在栈上的Block复制到堆时会进行调用。__main_block_dispose_0调用_Block_object_dispose，相当于release，释放赋值在对象类型的结构体变量中的对象。在堆上的Block被废弃时会被调用。
2.7 Block的内存管理
Block内存分析
block 在使用的时候，堆block注意作用域的问题，弱引用指针赋值，出了作用域就释放了，可以通过强引用解决
3 Blcok的问题总结
1. block在修改NSMutableArray，需不需要添加__block？
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSMutableArray *array = [NSMutableArray array];
Block block = ^{
[array addObject: @"20"];
[array addObject: @"30"];
NSLog(@"%@",array);
};
block();
}
return 0;
可以正确执行，因为在block块中仅仅是使用了array的内存地址，往内存地址中添加内容，并没有修改arry的内存地址，因此array不需要使用__block修饰也可以正确编译。
‼️ 因此当仅仅是使用局部变量的内存地址，而不是修改的时候，尽量不要添加__block，通过上述分析我们知道一旦添加了__block修饰符，系统会自动创建相应的结构体，占用不必要的内存空间。
2. __block如何达到修改内部的值？
Block可以捕获值，看如下代码
原理： 首先被__block修饰的age变量声明变为名为age的__Block_byref_age_0结构体，也就是说加上__block修饰的话捕获到的block内的变量为__Block_byref_age_0类型的结构体
__Block_byref_age_0结构体
- __isa指针 ：__Block_byref_age_0中也有isa指针也就是说__Block_byref_age_0本质也一个对象。
- *__forwarding ：__forwarding是__Block_byref_age_0结构体类型的，并且__forwarding存储的值为(__Block_byref_age_0 )&age，即结构体自己的内存地址。
- __flags ：0
- __size ：sizeof(__Block_byref_age_0)即__Block_byref_age_0所占用的内存空间。
- age ：真正存储变量的地方，这里存储局部变量10。
接着将__Block_byref_age_0结构体age存入__main_block_impl_0结构体中，并赋值给__Block_byref_age_0 *age;
之后调用block，首先取出__main_block_impl_0中的age，通过age结构体拿到__forwarding指针，__forwarding中保存的就是__Block_byref_age_0结构体本身，这里也就是age(__Block_byref_age_0)，在通过__forwarding拿到结构体中的age(10)变量并修改其值。
__forwarding是指向自己的指针。
总结：__block为什么能够修改变量的值是因为__block把变量包装成了一个带有指针的对象，然后把age封装在结构体里面，block内部存储的变量为结构体指针，也可以通过指针找到内存地址修改变量的值。
__block 和Block 总结
Block本质是一个对象，使用结构体实现。
//Block结构体
struct __main_block_impl_0 {
struct __block_impl impl;//impl:Block的实际函数指针，就是指向包含Block主体部分的__main_block_func_0结构体
struct __main_block_desc_0* Desc;//Desc指针，指向包含Block附加信息的__main_block_desc_0()结构体
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {//__main_block_impl_0:Block构造函数（可以看到都是对上方两个成员变量的赋值操作）
impl.isa = &_NSConcreteStackBlock; //
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
__block作用：可以获取对应变量的指针，使其可以在block内部被修改。
__block的数据结构如下
struct __Block_byref_a_0 {
void *__isa;//有isa，是一个对象
__Block_byref_a_0 *__forwarding;//指向自身类型对象的指针
int __flags;//不用关心
int __size;//自己所占大小
int a;//被封装的 基本数据类型变量
};
Block为什么用copy修饰
因为Block的内存地址显示在栈区，栈区的特点就是创建的对象随时销毁，一旦销毁后续再次调用空对象就会造成程序崩溃。
对Block进行copy操作之后，block存在堆区，所以在使用Block属性的时候Copy修饰。
堆中的block，也就是copy修饰的block。他的生命周期就是随着对象的销毁而结束的。只要对象不销毁，我们就可以调用的到在堆中的block。
这就是为什么我们要用copy来修饰block。因为不用copy修饰的访问外部变量的block，只在他所在的函数被调用的那一瞬间可以使用。之后就消失了。
注意：ARC的Block一般都是在堆上，因为系统默认堆Block进行copy操作。 不论ARC还是MRC 用copy Strong修饰Block都是堆Block。
