1. block的本质
- block本质上也是一个OC对象，它内部也有个isa指针。
- block是封装了函数调用以及函数调用环境(block函数的调用地址、参数、变量等信息)的OC对象。
- block的底层结构代码如下：
- 首先在main函数中申明一个block
// 首先在main函数中申明一个block
int main(int argc, const char * argv[]) {
@autoreleasepool {
int age = 20;
// 申明一个block
void (^block)(int, int) = ^(int a , int b){
NSLog(@"this is a block! -- %d", age);
NSLog(@"this is a block!");
NSLog(@"this is a block!");
NSLog(@"this is a block!");
};
}
return 0;
}
2.将main函数的oc代码转成C++代码，具体看下block的底层实现结构如下：
// 将main函数的oc代码转成C++代码，具体看下block的底层实现结构如下：
// oc中申明的block代码底层实现是一个__main_block_impl_0的结构体
struct __main_block_impl_0 {
// impl：是__block_impl类型的结构体，其内部有个isa指针，所以block的本质是一个oc对象。
struct __block_impl impl;
// Desc：是__main_block_desc_0类型的结构体。
struct __main_block_desc_0* Desc;
// age：是main函数中申明的局部变量age
int age;
// c++的构造方法，类似于oc的init构造方法
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int flags=0) : age(_age) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
// impl的结构体内部实现：
struct __block_impl {
void *isa;
// 默认为0
int Flags;
int Reserved;
// FuncPtr：block内部函数执行地址
void *FuncPtr;
};
// Desc的结构体内部实现：
static struct __main_block_desc_0 {
size_t reserved;
// Block_size：block的内存空间大小
size_t Block_size;
}
- block的底层结构如右图所示：
底层结构.png
2. block的变量捕获（capture）
为了保证block内部能够正常访问外部的变量，block有个变量捕获机制。判断会不会被捕获的标准是：如果是全局变量不会捕获，如果是局部变量则会捕获。
捕获机制.png
代码演示如下：
// auto：自动变量，离开作用域就销毁（平时申明的变量前面默认auto类型，auto是省略了）
auto int age = 10;
static int height = 10;
void (^block)(void) = ^{
// age的值捕获进来（capture）height的地址捕获进来
NSLog(@"age is %d, height is %d", age, height);
};
// 值传递
age = 20;
// 指针传递
height = 20;
// 打印结果：age is 10, height is 20
block();
默认方法入参.png
3. block的类型
(1) block有3种类型，可以通过调用class方法或者isa指针查看具体类型，最终都是继承自NSBlock类型。
-
__NSGlobalBlock__ （ _NSConcreteGlobalBlock ）存放在数据区域。没有访问auto变量时，就是该类型block。 -
__NSStackBlock__ （ _NSConcreteStackBlock ）存放在栈段。访问了auto变量时，就是该类型block。 -
__NSMallocBlock__ （ _NSConcreteMallocBlock ）存放在堆段。NSStackBlock类型block调用了copy函数时就是该类型。
存储位置示意图：PS：各存储位置存储内容：存储位置.png - 程序区域：程序编译时，将代码相关数据存储在此区域。无需开发者管理。
- 数据区域：程序编译时，全局变量数据存储在此区域。无需开发者管理。
- 堆：程序运行时，动态分配内存,需要开发者申请内存，也需要开发者自己管理内存。
- 栈：系统自动分配内存，自己销毁。存放局部变量数据，离开作用域时内存销毁。
调用copy结果.png
(3) block的copy操作：
- 在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上（block会变成NSMallocBlock类型），比如以下情况：
1. block作为函数返回值时；
2. 将block赋值给__strong指针时；
3. block作为Cocoa API中方法名含有usingBlock的方法参数时；
4. block作为GCD API的方法参数时；
- ARC下block属性的建议写法：
@property (strong, nonatomic) void (^block)(void);
@property (copy, nonatomic) void (^block)(void); - MRC下block属性的建议写法:
@property (copy, nonatomic) void (^block)(void);
4. block内部访问对象类型的auto变量
当block内部访问了对象类型的auto变量时：
- 如果block是在栈上，将不会对auto变量产生强引用。
- 如果block被拷贝到堆上：1. 会调用block内部的copy函数；2. copy函数内部会调用
_Block_object_assign函数；3._Block_object_assign函数会根据auto变量的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（做一次retain操作）或者弱引用； - 如果block从堆上移除。1. 会调用block内部的
dispose函数；2. dispose函数内部会调用_Block_object_dispose函数；3._Block_object_dispose函数会断开对auto变量的引用（做一次release操作）；函数调用时机.png
5. block关于__block修饰变量
- __block可以用于解决block内部无法修改auto变量值的问题。
- __block不能修饰全局变量、静态变量（static）。
- 编译器会将__block修饰符的变量包装成一个对象。底层掩饰如下
// 申明一个__block修饰符变量
typedef void (^MJBlock)(void);
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block int age = 10;
MJBlock block1 = ^{
age = 20;
NSLog(@"age is %d", age);
};
block1();
}
return 0;
}
// 上述oc代码转成c++底层代码，__block int age的结构
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
/* __block int age变量被包装成__Block_byref_age_0类型的结构体，结构体里
有isa指针，实质是oc对象。
block修改age的值是通过*age ->forwarding->age来修改的
*/
__Block_byref_age_0 *age;
};
// __Block_byref_age_0结构体：
struct __Block_byref_age_0 {
void *__isa;
// 存放指向自己的内存地址
__Block_byref_age_0 *__forwarding;
int __flags;
int __size;
// __block int age变量 age的值
int age;
};
-
__block修饰变量的内存管理
当block在栈上时，并不会对__block变量产生强引用
-
当block被copy到堆时:1. 会调用block内部的copy函数；2. copy函数内部会调用
_Block_object_assign函数；3._Block_object_assign函数会对__block变量形成强引用（做一次retain操作）;引用流程图.png -
当block从堆中移除时: 1. 会调用block内部的
dispose函数；2. dispose函数内部会调用_Block_object_dispose函数；3._Block_object_dispose函数会断开对__block变量的引用（做一次release操作）；移除流程图.png
-
__block修饰的对象变量内存管理
- 当block在栈上时，并不会对__block变量产生强引用；
- 当block被copy到堆时:1. 会调用block内部的copy函数；2.
_Block_object_assign函数会根据所指向对象的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用（注意：这里仅限于ARC时会retain，MRC时不会retain）；3._Block_object_assign函数会对__block变量形成强引用（做一次retain操作）； - 当block从堆中移除时: 1. 会调用block内部的
dispose函数；2. dispose函数内部会调用_Block_object_dispose函数；3._Block_object_dispose函数会断开对__block对象变量的引用（做一次release操作）；
-
__block修饰变量的__forwarding指针。
这样做的原因是：如果block在栈上时， __forwarding指针指向是栈上的block， 如果block copy到堆上时， __forwarding指针指向的是堆上的block， 通过__forwarding指针来访问变量，就可以保证访问的变量是堆上的变量。流程图如下：
上面提到，__block修饰符变量的底层是包装成一个oc对象，其内部有一个指向自己的__forwarding指针，访问__block变量是通过__forwarding访问自己内部的__block变量。
访问流程.png
6. block循环引用问题
- 什么是block循环引
循环引用是指对象之间的强引用链形成了环就创造了一个循环引用。最简单的情况，两个对象之间强引用，你引用我，我引用你，导致内存无法释放，就形成了循环引用。
block 的循环引用情况是，block 会捕获内部使用的对象，形成隐式的强引用，一般有以下两种常见的情况：- 引用 self：直接写 self：
2.成员变量：不写 self，但实际上还是对 self 的强引用：self.callback = ^{ NSLog(@"callback: %@", self);}self.callback = ^{ NSLog(@"callback: %@", _name); // 等价于 NSLog(@"callback: %@", self->_name); } - ARC-解决循环引用问题
- 用__weak解决,不会产生强引用，指向的对象销毁时，会自动让指针置为nil。
MJPerson *person = [[MJPerson alloc] init]; __weak typeof(person) weakSelf = person; person.block = ^{ NSLog(@"age is %d", weakSelf.age); }- 用__unsafe_unretained解决,不会产生强引用，不安全，指向的对象销毁时，指针存储的地址值不变，所以一般不常用。
MJPerson *person = [[MJPerson alloc] init]; __unsafe_unretained typeof(person) weakPerson = person; person.block = ^{ NSLog(@"age is %d", weakPerson.age); };- 用__block解决（必须要调用block）,缺点：1. 必须要将block强引用的对象置空，且block一定要调用；2. 一定要等到block执行完，对象才能被释放。如果这个block一直没有被调用，对象就一直不会被释放，就会存在内存泄露。
block解决循环引用示意图.png
代码演示：
__block MJPerson *person = [[MJPerson alloc] init]; person.block = ^{ person.age = 20; NSLog(@"age is %d", person.age); person = nil }; person.block(); - MRC-解决循环引用问题（不支持__weak）
- 用__unsafe_unretained解决
image.png
- 用__block解决
image.png
- 用__unsafe_unretained解决