文章目录
Block语法（7.26补充）
Block是带有自动变量（局部变量）的匿名函数
完整的Block语法与一般的c语言函数相比，仅有两点不同：
- 没有函数名
- 返回值类型前带有
^
void test(int num) {
}
^ void(int num) {
}
Block结构：^ 返回值类型 参数列表 表达式
其中我们可以省略返回值类型
- 表达式中有return语句，就使用该返回值的类型
- 没有return语句，就使用void类型
如果不使用参数，参数列表也可以省略
^(int count) { return count; }
//相等于
^ int(int count) { return count; }
------
^ { printf("1"); }
//相等于
^ void(void){ printf("1"); }
Block类型变量 （7.26补充）
在Block语法下，可将Block语法赋值给声明为Block类型的变量，即Block语法就相当于是生成了可赋值给Block类型变量的值。
声明Block类型变量：
int (^blk)(int);
//c语言中声明函数指针
int (*ptr)(int);
我们可以看到声明Block类信变量仅仅是将声明函数指针类型变量中的*变成了^。
Block类型变量可作为自动变量、函数参数、静态变量、静态全局变量、全局变量。
但是这种记述会比较麻烦，我们可以用typedef来声明Block类型
typedef int (^Blk) (int);
//使用typedef记述前后比较
//使用前
void func(int (^blk) (int)) {
}
//使用后
void func(Blk blk) {
}
Block的实质
Block是“带有自动变量值的匿名函数”。
block是封装了函数调用以及函数调用环境的OC对象
我们可以通过clang -rewrite-objc 源代码文件名，将源代码转换为c++源代码。
先在main.m写一个简单的block
通过clang可转换为：
//Block结构
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
//构造函数 初始化对象
//参数1 fp:函数指针
//参数2 desc：作为静态全局变量初始化的 __main_block_desc_0 结构体实例 指针
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
//这里说明一下，Block就是OC对象
impl.isa = &_NSConcreteStackBlock; //先理解为block的类型
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
//block的实现部分结构体
struct __block_impl {
void *isa;
int Flags; //标识符
int Reserved; //今后版本升级所需的区域
void *FuncPtr; //函数指针
};
//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花括号执行的代码，匿名函数
//参数__cself 是 __main_block_impl_0结构体指针，
//指向Block值的变量 相当于oc的self，c++中的this
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf("Block");
}
//main
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
NSLog((NSString *)&__NSConstantStringImpl__var_folders_4g_7vx2fqwn6gqbt88r3s77sd6c0000gn_T_main_10fc97_mi_0);
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);
}
return 0;
}
对比看一下main函数里面关于block的那两条代码
void (^myBlock)(void) = ^{
printf("Block");
};
//对应c++
void (*myBlock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
//去掉强制转换 简化一下c++代码
void (*myBlock)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
// 该源代码中Block就是__main_block_impl_0结构体类型的自动变量，即栈上生成的 __main_block_impl_0结构体实例
//myblock变量的值为 __main_block_impl_0 函数返回值的地址。
//即栈上生成的__main_block_impl_0结构体实例的指针， 赋值给结构体指针变量myBlock
//第一个参数是 转换后匿名函数的地址
//第二个参数 作为静态全局变量初始化的 __main_block_desc_0 结构体实例 指针
//初始化部分见__main_block_desc_0结构体定义部分
//-----------------------
myBlock();
//对应c++
((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
//简化c++
//myBlock作为参数进行传递给func0函数的__cself
myBlock->FuncPtr(myBlock);
Block变量截获
- 局部变量，只有局部作用域，它是自动对象（auto），只在函数执行期间存在，函数的一次调用执行结束后，变量被撤销，其所占用的内存也被收回。
- 静态局部变量，具有局部作用域，它只被初始化一次，自从第一次被初始化直到程序运行结束都一直存在，它和全局变量的区别在于全局变量对所有的函数都是可见的，而静态局部变量
只对定义自己的函数体始终可见，每次被调用都使用上一次的值。 - 全局变量，具有全局作用域。全局变量只需在一个源文件中定义，就可以作用于所有的源文件。当然，其他不包含全局变量定义的源文件需要用extern 关键字再次声明这个全局变量。
- 静态全局变量，也具有全局作用域，它与全局变量的区别在于如果程序包含多个文件的话，它作用于定义它的文件里，不能作用到其它文件里，即被static关键字修饰过的变量具有文件作用域。这样即使两个不同的源文件都定义了相同名字的静态全局变量，它们也是不同的变量。
局部变量截获，值截获
执行这段代码，打印结果为
转换为c++，生成的有关代码
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int a; //与之前转换不同的是，多了一个a
// : a(_a) 相当于a = _a, _a为1
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_4g_7vx2fqwn6gqbt88r3s77sd6c0000gn_T_main_f2b4ed_mi_0, a);
}
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int a = 1;
void (*block1)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a)); //这里参数a为1
a = 10;
((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);
// block1->FuncPtr(block1);
}
return 0;
}
（7.26补充）
如果局部变量是指针类型的话，同样也是值截获，只不过截获的变量存储的是某一类型地址的指针变量，同样不能修改a的值，只不过可通过*a来修改指针a指向的变量或对象的值
最后通过打印，我们可以知道block截获的局部非静态变量与main中的变量并不是同一份，也应证了上面的源码分析
（MRC下的打印，关于MRC、ARC后面有解释）
静态局部变量截获，指针截获
打印结果：
转换为c++
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
//新增的成员变量
int a;
int *b; //与局部变量不同的是， 新增指针变量b，注意是指针变量！！！！！
//_b为block外部 局部变量b的地址， 赋值为block的成员变量b，b为指向int型的指针类型
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int *_b, int flags=0) : a(_a), b(_b) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
int *b = __cself->b; // bound by copy
//打印指针变量b指向的地址上的值
NSLog((NSString *)&__NSConstantStringImpl__var_folders_4g_7vx2fqwn6gqbt88r3s77sd6c0000gn_T_main_d2e5ae_mi_0, a, (*b));
}
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int a = 1;
static int b = 2;
//注意这里参数传的是 静态局部变量b 的地址！！！！！
void (*block1)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a, &b));
a = 10;
b = 20;
((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);
}
return 0;
}
全局变量、静态全局变量不截获，直接取值
打印结果如下：
转换为c++
相关代码如下：
int c = 3;
static int d = 4;
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
//这里没有新增成员变量，不截获
__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;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
//打印也是直接打印的全局变量c， 全局静态变量d
NSLog((NSString *)&__NSConstantStringImpl__var_folders_4g_7vx2fqwn6gqbt88r3s77sd6c0000gn_T_main_065b6e_mi_0, c, d);
}
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
void (*block1)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
c = 30;
d = 40;
((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);
}
return 0;
}
（7.26补充）
下例中，block截获的是指向NSMutableArray对象的指针变量array，它也是一个局部非静态变量，被block截获，在block中不能修改它的值
但我们可以在block中使用它，通过它来操作NSMutableArray对象
如果Block中截获了c语言数组的话，就算不在block中修改数组，编译也会出错
上述源码分析中，Block构造函数会直接将原变量的值赋值给截获的变量。
在C语言中，不允许数组类型直接赋值给数组类型，在现在的Block中，截获自动变量的方法并没有实现对c语言数组的截获。
这时候，使用指针可解决这一问题
总结
对于block对变量是否截获，可以从变量的作用域来进行理解
- 局部变量，值截获。
- 静态局部变量，指针截获。
- 全局变量、静态全局变量，不截获，直接取值。
另外，对于block里访问self、成员变量都会去截获self。转为c++的代码，self会作为函数的参数，作用域也为当前函数，可以把它当作局部变量来理解和分析。
Block存储域
_NSConcreteStackBlock类，存储域：栈
_NSConcreteGlobalBlock类，存储域：数据区
_NSconcreteMallocBlock类，存储域：堆
（补充auto表示作为自动变量存储在栈上）
- 首先，没有访问auto变量的都是Global
- 使用了auto变量并且未进行copy操作的Block都是栈Block（以下为MRC）
- 由于设置在栈上的Block超出其作用域就会被废弃，所以可以将其复制到堆上，这时Block的类为_NSConcreMallocBlock (以下为MRC)
注意：上面强调了实例代码为MRC，对于ARC，其实大多情况下编译器会恰当地进行判断，自动生成将Block从栈上复制到对堆上的代码。
情况如下：
- Block作为函数返回值返回时
- 将Block赋值给有__strong修饰符id类型的的类或Block类型成员变量时
- 在方法名中含有usingBlock的Cocoa框架方法
- GCD的API传递Block时
另外比如向方法或函数的参数中传递Block时，不会自动复制到堆上，
这时就会报错， getBlockArray中的Block们是栈上的Block，在ARC下作为参数并不会自动复制到栈上，函数执行完，栈上的Block就会自动销毁，main函数中访问array中的元素就会出错。
我们可以通过copy手动将Block复制到堆上
数据区的Block进行copy，存储域还是在数据区
-
栈Block进行copy，存储域变为堆
-
堆Block进行copy，引用计数+1
三种Block进行copy的效果如表所示：
__block说明符
首先看代码
若想在Block语法的表达式中将值赋给Block语法外声明的自动变量，需要在该自动变量上附加__block说明符。
我们可以看看转为c++代码
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
// __block变量为结构体类型的自动变量
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding; //指向自身的指针
int __flags;
int __size;
int a; //相当于原自动变量
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_a_0 *a; //注意！！截获__block变量，截获的是指针
__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;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_a_0 *a = __cself->a; // bound by ref
(a->__forwarding->a) = 2;
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0,
sizeof(struct __main_block_impl_0),
__main_block_copy_0,
__main_block_dispose_0
};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
__attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 1};
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
printf("%d\n", (a.__forwarding->a));
return 0;
}
}
//main中代码简化
__Block_byref_a_0 a = {0,
&a,
0,
sizeof(__Block_byref_a_0),
1};
//对应oc中
__block int a = 1;
//__block变量a变成了栈上生成的 __Block_byref_a_0结构体实例
//通过 __Block_byref_a_0结构体的定义，原自动变量相当于该结构体的成员变量
__block变量存储域
在一个Block中使用了外部定义的__block变量， 则当该Block复制到堆上的时候，__block变量也会全部被从栈复制到堆上，此时Block持有__block变量。而Block已经复制到堆上，再复制Block对所使用的__block变量没有影响。
多个Block中使用一个__block变量时，最初所有的Block都在栈上，__block变量也一定在栈上，此时栈上的block并不会对栈上的__block变量产生引用计数。
当有一个Block从栈复制到堆上时，__block也会被复制到堆上并被该Block持有。当其他Block再从栈复制到堆上时，持有__block变量，增加__block变量的引用计数。
当Block被copy到堆上，会调用block内部的copy函数，从copy函数内部会调用_Block_object_assign函数，_Block_object_assign函数会对__block变量形成强引用。
具体如图：
当堆上的Block被废弃时，堆上的__block会因没有持有者而会被废弃。
具体如图：
了解了__block的存储域之后，对于__block变量所转换的结构体中的__forwarding指针，之前说他是指向自身的指针。
栈上的__block变量在__block变量从栈上复制到堆上时，会将成员变量__forwarding的值替换为复制目标堆上的__block变量的结构体实例的地址。
它的作用是无论是在Block外、还是Block内使用__block变量，无论__block变量在栈上还是在堆上，都能正确的访问该变量，访问的是同一个__block变量
截获对象
这段代码中（ARC），Block截获了array，所以array指针变量作用域结束，Block内部还持有array对象，所以array不会被废弃。
转为c++：
//这里展示部分代码
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
NSMutableArray *__strong array; //截获的对象
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSMutableArray *__strong _array, int flags=0) : array(_array) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0,
sizeof(struct __main_block_impl_0),
__main_block_copy_0, //函数指针
__main_block_dispose_0 //函数指针
};
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
_Block_object_assign((void*)&dst->array, (void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
Objective-C的运行时库能够准确把握Block从栈复制到堆上，以及堆上的Block被废弃的时机，所以Block的结构体中可以含有附有__strong、__weak修饰符的变量，可以对其进行初始化和废弃，为此需要使用在__main_block_desc_0结构体中增加的成员变量copy和dispose，以及作为指针的__main_block_copy_0和__main_block_dispose_0函数，赋值给成员变量copy、dispose。
- __main_block_copy_0函数：使用_Block_object_assign函数将对象赋值给Block内部截获的成员变量array，并持有对象。_Block_object_assign函数调用相当于retain。
- __main_block_dispose_0函数：使用_Block_object_dispose函数，释放赋值在Block结构体成员变量array的对象。_Block_object_dispose函数调用相当于release。
在Block从栈复制到堆时以及堆上Block被废弃时会调用这些函数。
在前面截获__block变量时，desc结构体中也有相应的copy、dispose，以及__main_block_copy_0和__main_block_dispose_0函数，唯一不同的是_Block_object_assign和_Block_object_dispose的参数
//持有截获的对象
_Block_object_assign((void*)&dst->array, (void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
//释放截获的对象
_Block_object_dispose((void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);
//持有截获的__Blcok变量
_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
//释放截获的__Blcok变量
_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
当Block从栈上被复制到堆上时，如果截获的是__block变量，__block变量也会被复制到堆上（__block变量原本不在堆上），那么堆上的Block强引用堆上的__block变量。如果截获的是对象，要看截获的对象的修饰符是weak还是strong，是weak则调用copy持有对象的弱引用，是strong则调用copy持有对象的强引用。
(补充)
Block截获对象时对对象的引用计数的影响（ARC下）
Block截获__block修饰的对象时对对象的引用计数的影响（ARC下）
NSObject实例对象的引用计数为1，
截获__block 修饰的对象
转为c++
//__block变量的结构
struct __Block_byref_obj1_0 {
void *__isa;
__Block_byref_obj1_0 *__forwarding;
int __flags;
int __size;
//因__block修饰的是对象，所以在__block复制到堆上以及从堆上废弃，应在恰当时机对其成员变量obj1进行相应的内存管理
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
NSObject *__strong obj1; //原__strong修饰的对象类型的变量
};
//当__block复制到堆上，持有赋值给__block变量的对象
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
_Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
}
//当堆上的__block变量被废弃时，释放赋值给__block变量的对象
static void __Block_byref_id_object_dispose_131(void *src) {
_Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}
//Block结构
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_obj1_0 *obj1; // by ref. 截获的__block变量 注意是指针
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_obj1_0 *_obj1, int flags=0) : obj1(_obj1->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0,
sizeof(struct __main_block_impl_0),
__main_block_copy_0,
__main_block_dispose_0}; //初始化的静态全局变量
// __main_block_desc_0_DATA 的三、四参数为函数指针
//函数如下所示
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
_Block_object_assign((void*)&dst->obj1, (void*)src->obj1, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->obj1, 8/*BLOCK_FIELD_IS_BYREF*/);
}
//Block花括号内的匿名函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_obj1_0 *obj1 = __cself->obj1; // bound by ref
NSLog((NSString *)&__NSConstantStringImpl__var_folders_4g_7vx2fqwn6gqbt88r3s77sd6c0000gn_T_main_834c11_mi_0, (obj1->__forwarding->obj1));
}
int main(int argc, const char * argv[]) {
Blk blk;
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
NSObject *obj = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));
__attribute__((__blocks__(byref))) __Block_byref_obj1_0 obj1 = {(void*)0,(__Block_byref_obj1_0 *)&obj1, 33554432, sizeof(__Block_byref_obj1_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, obj};
Blk blk1 = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_obj1_0 *)&obj1, 570425344));
((void (*)(__block_impl *))((__block_impl *)blk1)->FuncPtr)((__block_impl *)blk1);
}
return 0;
}
//mian中的简化
//__block NSObject *obj1 = obj;
__Block_byref_obj1_0 obj1 = {0,
&obj1,
33554432,
sizeof(__Block_byref_obj1_0),
__Block_byref_id_object_copy_131,
__Block_byref_id_object_dispose_131,
obj};
//blk1的初始化
Blk blk1 = &__main_block_impl_0(__main_block_func_0,
&__main_block_desc_0_DATA,
(__Block_byref_obj1_0 *)&obj1,
570425344);
//blk1();
(blk1->FuncPtr)(blk1);
大致的内存管理如下：
在这一过程中
- Block截获__block变量，结构体中生成了指向__block变量的指针；
- 而__block修饰的是一个对象类型的变量，即__block结构体中有一个对象类型的指针变量；
- __block以及Block最初都在栈上，栈上的Block只是使用栈上的__Block变量，并不持有。
- 当Block复制到了堆上，截获的__block也会复制到堆上，通过Block的__main_block_copy_0、__main_block_dispose_0函数对__block进行相应的持有和释放。
- 当__block复制到了堆上，那么就会使用__block中的__Block_byref_id_object_copy、__Block_byref_id_object_dispose并且根据对象类型的所有权修饰符（weak、strong）进行相应的强引用、弱引用、以及释放
对象类型被__weak修饰，那么复制到堆上的__block会调用__Block_byref_id_object_copy持有对象的弱引用。对象类型被__strong修饰，那么复制到堆上的__block会调用__Block_byref_id_object_dispose持有对象的强引用。
堆上的__block被废弃时，若原来持有对象，使用__Block_byref_id_object_dispose释放所持有的对象。
Block循环引用
ARC环境下
使用Block经常会引起循环引用问题
@interface Person : NSObject
@property (nonatomic, strong) void(^blk)(void);
@end
@implementation Person
- (instancetype)init
{
self = [super init];
if (self) {
_blk = ^{
NSLog(@"%@", self);
};
}
return self;
}
- (void)dealloc {
NSLog(@"dealloc");
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person1 *person = [[Person1 alloc] init];
} //person强引用失效，此时应该执行dealloc，
//但由于循环引用，person.blk持有person，person又持有blk
//造成内存泄漏
}
//截获self，转为c++
struct __Person1__init_block_impl_0 {
struct __block_impl impl;
struct __Person1__init_block_desc_0* Desc;
Person1 *__strong self; //Block的成员变量，强引用self
__Person1__init_block_impl_0(void *fp, struct __Person1__init_block_desc_0 *desc, Person1 *__strong _self, int flags=0) : self(_self) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
上述代码中的循环引用如图所示
要解决上面的循环引用问题，有两种方法
使用__weak、__unsafe_unretained
使其中一个不持有对方，要注意的是，这里对象必须持有Block，因为必须保证self存在时Block必存在，所以Block要弱引用self。
- 对于__weak和__unsafe_retained的区别
之前ARC中有提到过，__weak修饰的指针变量所指的对象销毁，该指针变量置nil，__unsafe_unretained所指对象销毁时，依然指的是原地址，所以可能导致野指针错误。
//修改部分
- (instancetype)init
{
self = [super init];
if (self) {
__weak typeof(self) weakSelf = self; //typeof
_blk = ^{
NSLog(@"%@", weakSelf);
};
}
return self;
}
使用__block变量
先看代码
//部分代码
- (instancetype)init
{
self = [super init];
if (self) {
//__weak typeof(self) weakSelf = self;
__block id tmp = self;
_blk = ^{
NSLog(@"%@", tmp);
tmp = nil;
};
}
return self;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person1 *person = [[Person1 alloc] init];
person.blk(); //！！！！！！！！！！！！
}
}
- (void)dealloc {
NSLog(@"dealloc");
}
运行会打印dealloc，没有引起循环引用
但是如果不调用person.blk();，则会引起循环引用,如图（图错了，应该是Block持有__block变量）
- self持有Block
- Block持有__block变量
- __block变量持有self
执行Block内部函数，__block变量tmp置nil，避免循环引用
使用__block变量来避免循环引用一定要注意调用Block，执行其内部函数
上述的循环引用是在ARC环境下
MRC环境下
首先说明一点，在MRC环境下，__Block变量复制到堆上并不会对其所修饰的对象进行retain操作
所以，MRC环境下可通过__block、__unsafe_unretained来避免循环引用
（__weak只能在ARC下使用）
强弱共舞
- __weak是为了解决循环引用
- __strong是为了防止block持有的对象提前释放
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
__weak typeof(self) weakSelf = self;
self.blk = ^{
//__strong typeof(self) strongSelf = weakSelf;
//5秒后执行
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", weakSelf);
//NSLog(@"%@", strongSelf);
});
};
self.blk();
[self dismissViewControllerAnimated:YES completion:nil];
}
- (void)dealloc {
NSLog(@"nextVC dealloc");
}
这里涉及到了延时操作
执行这段代码，VC会先销毁，五秒后执行Block内部函数打印的self会为null
若在Block内用__strong变量通过__weak变量强引用self，则会保证在执行Block内部时，self不会被释放， 超出strongSelf变量作用域，取消对self的持有。
将对应代码换为注释的代码
运行结果如下
2110
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
