本章目录
- Block截取自动变量
- __block说明符
- Block存储域
- __block变量存储域
- Block中截获对象
- Block的copy函数 与 dispose函数调用时机
- __block变量和对象
- Block循环引用
- ARC无效时Block的copy / release
- 参考文献
Block截取自动变量
- 如何截获自动变量?
Block语法转换成C函数后,Block语法表达式中用到的自动变量会被作为成员变量追加到了__main_block_impl_0结构体中。
而此结构体中的成员变量类型与自动变量类型完全相同,但仅限于Block语法中使用到的自动变量。
因此,所谓“截获自动变量值”意味着执行Block语法时,Block语法表达式所使用的自动变量值被保存到Block的结构体实例中。
- 为什么Block语法中不能使用数组(C语言创建的数组)?
因为结构体中的成员变量与自动变量类型完全相同。
所以结构体中使用数组截取数组值,而后调用时再赋值给另一个数组。
也就是数组赋值给数组,这在C语言中是不被允许的。
简单来说:Block转化后,是个C语言的Struct结构体。在C语言里,数组是不能直接赋值给数组的。所以,Block中无法截获C语言中的数组,因为对于C语言数组而言,直接赋值会报错。
而我们平常对NSMutableArray的增删和遍历操作是可以用的,但是遍历时不可进行删操作,否则数组越界报错。
__block说明符
在Block中修改截获的自动变量值有两种方法。
第一种:使用静态变量,静态全局变量,全局变量
从Block语法转换成的C语言函数中访问静态全局变量 / 全局变量并没有任何改变,可直接使用。
但是静态变量却是用静态变量的指针来对其进行访问,这是超出作用域使用变量的最简单方法。
- 为何静态变量的这种方法不适用于自动变量?
因为静态变量会存储在堆上,而自动变量却存在栈上。
当超出其作用域的时候,静态变量还会存在,而自动变量所占内存则会被释放因而被废弃。所以不能通过指针访问原来的自动变量。
- 第二种方法: 使用 “ __block ” 修饰符
__block存储域类说明符。存储域类说明符,指定将变量设置到哪个存储域中,如:auto 栈 , static 堆 , extern 全局 , register 寄存器 ,
若将__block修饰符修饰在一个自动变量前,如:
int main() {
__block int val = 10;
void (^blk)(void) = ^{val = 1;};
}
通过clang编译后提取的Block相关代码为:
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
struct __Block_byref_val_0 {
void *__isa;
__Block_byref_val_0 *__forwarding;
int __flags;
int __size;
int val;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_val_0 *val; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__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_val_0 *val = __cself->val; // bound by ref
(val->__forwarding->val) = 1;}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 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() {
__attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 10};
void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));
}
在此源码中,__block(前面有两个“ _ ”,这个markDown编译器为何把这两个符号给吞了 )所修饰的变量也同Block一样变成了__Block_byref_val_0结构体类型的自动变量,即栈上生成的__Block_byref_val_0结构体实例。
关于此结构体的声明:
struct __Block_byref_val_0 {
void *__isa; (isa指针,指向一个存储有自身基础信息的地址,类似OC中的元类)
__Block_byref_val_0 *__forwarding; (forwarding指针,指向自身)
int __flags; (标记)
int __size; (大小)
int val; (存储的值,相当于原自动变量的成员变量)
};
给__block变量赋值的代码 ^{val = 1;}; 会被转换为:
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_val_0 *val = __cself->val; // bound by ref
(val->__forwarding->val) = 1;
}
刚刚在Block中向静态变量赋值时,使用了指向该静态变量的指针。
而向__block变量赋值时(又吞了),Block的__main_block_impl_0结构体实例会持有指向__block变量的_Block_byref_val_0 结构体实例的指针。
也就是Block的__main_block_impl_0结构体实例会持有一个指针,指向__block修饰的变量所转换的__Block_byref_val_0结构体实例。
而__Block_byref_val_0结构体通过成员变量__forwarding指针访问成员变量val
另外,为了能在多个Block中使用__block变量,__block变量的__Block_byref_val_0结构体并不在Block用__main_block_impl_0结构体中。
Block是通过__Block_byref_val_0结构体实例的指针来访问。
Block存储域
Block转换为Block的结构体类型的自动变量,__block(又吞了)变量转换为__block变量的结构体类型的自动变量。结构体类型的自动变量,即栈上生成的该结构体的实例。
所以,Block的实质是栈上Block的结构体实例,__block变量(又吞了)的实质是 栈上__block变量的结构体实例。
Block有三种类型:
_NSConcreteStackBlock
_NSConcreteGlobalBlock
_NSConcreteMallocBlock
Block的类型与Block的存储区域有关:
_NSConcreteStackBlock类的Block对象设置在栈上(Stack 栈)
_NSConcreteGlobalBlock类的Block对象与全局变量一样,设置在程序的数据区域(.data区)中(global 全局)
_NSConcreteMallocBlock类的Block对象则设置在堆中(Malloc 函数分配的内存块)
在声明全局变量的地方使用Block语法,生成的Block为_NSConcreteGlobalBlock
则该Block中的isa指针初始化时: impl.isa = &_NSConcreteGlobalBlock;
代表该Block的类为_NSConcreteGlobalBlock类。
则该Block结构体实例设置在程序的数据区域中。
还有一种情况,Block为_NSConcreteGlobalBlock类对象:
Block语法的表达式中不使用应截获的自动变量时。(注意是自动变量,包括函数形参和非static局部变量,说明这个变量是在栈上运行时自动创建自动撤销。)
因为在使用全局变量的地方不能使用自动变量,所以不存在对自动变量进行截获。
由此Block用结构体实例的内容不依赖于执行时的状态,所以整个程序中只需一个实例。
因此将Block用结构体实例设置在与全局变量相同的数据区域中即可。
也就是说只有当截获自动变量时,Block结构体实例截获的值才会根据执行时的状态变化。
而当Block语法的表达式中不使用应截获的自动变量时,Block结构体实例截获的值不会根据执行时的状态变化。
列如:
typedef int (^blk_t)(int);
for(int rate = 0; rate < 10; rate++){
blk_t blk = ^(int count){return rate * count;};
}
此Block结构体实例每次for循环中截获的值都不同,但去掉return rate * count 中的自动变量rate,则Block的结构体实例每次截获的值都完全相同。
所以:
记述全局变量的地方有Block语法时
Block语法的表达式中不使用应截获的自动变量时(函数形参和非static的局部变量)
在以上两种情况下,Block为_NSConcreteGlobalBlock类对象。即Block配置在程序的数据区域中。
那么,若Block使用了一个全局变量Int a,而 a 在每次使用前都会修改值。
如:
typedef int (^blk_t)(int);
extern int a ;
for(int rate = 0; rate < 10; rate++){
a = rate;
blk_t blk = ^(int count){return count;};
blk(a);
}
则该Block的类型仍旧为_NSConcreteGlobalBlock,因为并Block语法的表达式中没有使用应截获的自动变量,是直接使用的全局变量。
除此之外的Block语法生成的Block为_NSConcreteStackBlock类对象,且设置在栈上。
而栈上的Block通过Copy操作改变到堆上,就是_NSConcreteMallocBlock类对象。
设置在栈上的Block,如果其所属的变量作用域结束,该Block就会被废弃。
若__block变量也配置在栈上,如果其所属的变量作用域结束,则该__block(又吞)变量也会被废弃。
因此,Block通过Copy操作会复制到堆上,其所引用的__block(又吞)变量也会复制到堆上。
复制到堆上的Block其所属类型为:impl.isa = &_NSConcreteMallocBlock;
当__block变量复制到堆上时,之前所说的__block(又吞,下同,不再赘述)变量的结构体成员变量__forwading会指向复制到堆上的自身,由此实现无论__block变量配置在堆上还是栈上都能够正确的访问__block变量。
那么编译器何时会对Block自动判断进行Copy(复制)操作何时不能?
在ARC环境下自动判断进行Copy操作:
- 将Block作为函数参数返回值返回时,编译器会自动进行Copy操作。
- 将Block赋值给附有__strong修饰符id类型的类或Block类型成员变量
- 在方法名中含有usingBlock的Cocoa框架方法或GCD的API传递Block时
如果不能自动Copy,调用一下Copy实例方法就可以复制到堆上。
ARC环境下,返回一个对象时会先将该对象赋值给一个临时实例指针,而后对其进行retain操作,最后将对象注册到注册表中返回。
而runtime/objc-arr.mm里面有说明,Block的retain操作objc_retainBlock函数实际上是Block_copy函数。
在执行对Block的retain操作,objc_retainBlock函数执行后,栈上的Block复制到堆上,同时返回堆上的地址作为指针赋值给临时实例变量。
编译期不能自动判断进行Copy操作:
向方法或函数的参数中传递Block时。(注意:Cocoa框架中的方法,其方法名中若含有usingBlock等时 与 GCD的API中会自动判断进行Copy操作)。
如NSArray的initWithObjects需要手动执行Copy操作,而enumerateObjectsUsingBlock则不用,因为编译器会自动进行复制操作。
复制操作,就是Block的实例执行Copy实例方法即可。
- Block的复制效果
注意: 无论Block配置在何处,用copy方法复制都不会引起任何问题!包括内存泄露也不可能!不用担心无法进行releas操作!所以不确定的时候尽情调用Copy方法吧!
如:blk = [[[[blk copy] copy] copy] copy];
可转换为:
{
//第一次copy操作会将配置在栈上的Block赋值给变量blk中
//而后对blk进行Copy后,将配置在堆上的Block赋值给变量tmp
//此时变量tmp持有强引用的Block
blk_t tmp = [blk copy];
//将变量tmp的Block赋值为变量blk,变量blk持有强引用的Block
//因为之前赋值的Block配置在栈上,所以不受此赋值的影响。
//此时Block的持有者为变量blk 和 变量 tmp
blk = tmp;
}
//变量作用域结束,所以变量tmp被废弃,其强引用失效并释放所持有的Block
//由于Block被变量blk持有,所以没有被废弃
{
//配置在堆上的Block被赋值变量blk,同时变量blk持有强引用的Block
//配置在堆上的Block被赋值到变量tmp中,变量tmp持有强引用的Block
blk_t tmp = [blk copy];
//由于向变量blk进行了赋值,所以现在赋值的Block的强引用失效,Block被释放
//由于Block被变量tmp所持有,所以未被废弃
//变量blk中赋值了变量tmp的Block,变量blk持有强引用的Block
//此时Block的持有者为变量tmp与变量blk
blk = tmp;
}
//变量作用域结束,变量tmp被废弃
//强引用失效并释放所持有的Block
//由于变量blk还处于持有的状态,Block没有被废弃
//以下重复,先用一个变量tmp持有堆上的Block再赋值给blk
//于是blk释放旧值,保留新值
//超出变量作用域后释放tmp,此时只有blk持有
{
blk_t tmp = [blk copy];
blk = tmp;
}
{
blk_t tmp = [blk copy];
blk = tmp;
}
__block变量存储域
如图所示,一个Block从栈复制到堆时,使用的所有__block变量也都会复制到堆上并被Block持有。若此时__block变量已经在堆上,则被该Block持有。
若配置在堆上的Block被废弃,那么它所有的__block变量也就被释放。
在代码:
__block int val = 0;
void (^blk)(void) = [^{++val;} copy];
++val;
blk();
利用copy方法复制使用了__block变量的Block语法,于是二者都从栈复制到堆上。
而其中 ^{++val;} 与 ++val; 都可转换形式为: ++(val.__forwarding -> val);
在变换Block语法的函数中,该变量val为复制到堆上的__block变量的结构体实例。
而与Block无关的变量val,则为复制前栈上的__block变量用结构体实例。
但是栈上__block变量的结构体实例在__block变量从栈复制到堆上时,会将成员变量__forwarding的值替换为复制到目标堆上的__block变量用结构体实例的地址。如图:
由此实现无论Block语法中、语法外使用__block变量,还是__block变量配置在堆上或栈上,都可以顺利访问同一个__block变量。
Block中截获对象
在代码:
id array = [NSMutableArray array];
blk_t blk = ^(id obj){
[array addObject:obj];
NSLog(@"array count = %ld",[array count]);
};
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
输出结果为:
array count = 1
array count = 2
array count = 3
意味着赋值给变量array的对象在超出其变量作用域后仍存在。
将源码用clang编译后,截取Block相关的部分:
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
// @implementation block
struct __block__init_block_impl_0 {
struct __block_impl impl;
struct __block__init_block_desc_0* Desc;
id array;
__block__init_block_impl_0(void *fp, struct __block__init_block_desc_0 *desc, id _array, int flags=0) : array(_array) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __block__init_block_func_0(struct __block__init_block_impl_0 *__cself, id obj) {
id array = __cself->array; // bound by copy
((void (*)(id, SEL, ObjectType))(void *)objc_msgSend)((id)array, sel_registerName("addObject:"), (id)obj);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_t9_2587xc0n2dv6f08yv3mdbf7c0000gn_T_block_679c7b_mi_0,((NSUInteger (*)(id, SEL))(void *)objc_msgSend)((id)array, sel_registerName("count")));
}
static void __block__init_block_copy_0(struct __block__init_block_impl_0*dst, struct __block__init_block_impl_0*src) {_Block_object_assign((void*)&dst->array, (void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);}
static void __block__init_block_dispose_0(struct __block__init_block_impl_0*src) {_Block_object_dispose((void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);}
static struct __block__init_block_desc_0 {
size_t reserved;
size_t Block_size;
void (*copy)(struct __block__init_block_impl_0*, struct __block__init_block_impl_0*);
void (*dispose)(struct __block__init_block_impl_0*);
} __block__init_block_desc_0_DATA = { 0, sizeof(struct __block__init_block_impl_0), __block__init_block_copy_0, __block__init_block_dispose_0};
//使用部分
id array = ((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("array"));
blk_t blk = ((void (*)(id))&__block__init_block_impl_0((void *)__block__init_block_func_0, &__block__init_block_desc_0_DATA, array, 570425344));
((void (*)(__block_impl *, id))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init")));
((void (*)(__block_impl *, id))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init")));
((void (*)(__block_impl *, id))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk, ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init")));
转换一下:
id array = [NSMutableArray array];
blk = &__main_block_impl_0(__main_block_func_0,&__main_block_desc_0_DATA,array,570425344);
(*blk -> impl.FuncPtr)(blk,[[NSObject alloc] init]);
(*blk -> imply.FuncPtr)(blk,[[NSObject alloc] init]);
(*blk -> imply.FuncPtr)(blk,[[NSObject alloc] init]);b
请注意此结构体:
struct __block__init_block_impl_0 {
struct __block_impl impl;
struct __block__init_block_desc_0* Desc;
id array;
}
XCode8中对截获的变量array 不进行显示__strong(这里也有两个 “ _ ")修饰了,但依旧使用__block__init_block_copy_0 函数(在此之前是__main_block_copy_0) 和 __block__init_block_dispose_0函数(在此之前是__main_block_dispose_0)进行管理。
在此之前的OC中,C语言结构体不能含有附有__strong修饰符的变量,因为编译器不知道何时进行C语言结构体的初始化和废弃操作,因此不能很好地管理内存。
但是OC的运行库能准确把握Block从栈复制到堆以及堆上Block被废弃的时机。
因此Block的结构体中可以恰当地进行初始化和废弃,附有__strong修饰符或__weak修饰符的变量。
为此需使用在__main_block_desc_0结构体中增加的成员变量copy 和 dispose,以及作为指针赋值给该成员变量的__main_block_copy_0函数和__block__init_block_dispose_0函数。
但现在没有成员变量copy 和 dispose 而是直接使用函数指针__block__init_block_copy_0 函数 __block__init_block_dispose_0函数.
由于Block结构体中需要管理赋值给变量array的对象,因此__block(这里有四个 “ _ ")__init_block_copy_0函数通过_Block_object_assign函数将对象类型对象赋值给Block结构体的成员变量array中并持有该对象。
static void __block__init_block_copy_0(struct __block__init_block_impl_0*dst, struct __block__init_block_impl_0*src) {_Block_object_assign((void*)&dst->array, (void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);}
_Block_object_assign函数调用相当于retain实例方法的函数。
__block(又尼玛吞了四个“ _ ”!)__init_block_dispose_0 函数使用_Block_object_dispose函数,释放赋值在Block用结构体成员变量array中的对象。
static void __block__init_block_dispose_0(struct __block__init_block_impl_0*src) {_Block_object_dispose((void*)src->array, 3/*BLOCK_FIELD_IS_OBJECT*/);}
_Block_object_dispose函数调用相当于release实例方法的函数,释放赋值在对象类型的结构体成员变量中的对象。
Block的copy函数 与 dispose函数调用时机
- 什么时候栈上的Block会复制到堆上?
1.调用Block的copy实例方法
2.将Block作为函数参数返回值返回时,编译器会自动进行Copy操作。
3.将Block赋值给附有__strong修饰符id类型的类或Block类型成员变量
4.在方法名中含有usingBlock的Cocoa框架方法或GCD的API传递Block时
Block从栈复制到堆时_Block_copy函数被调用。
释放复制到堆上的Block,谁都不持有Block而使其被废弃时调用dispose函数。相当于对象的dealloc实例方法。
由于此种构造,Block中截获的对象就能够超出其变量作用域而存在。
另外,在使用__block变量时也是使用了copy函数和dispose函数来管理。
通过这两个参数来区分copy函数和dispose函数的对象类型对象还是__block变量。
copy函数持有截获的对象 或 持有所使用的__block变量,dispose函数释放截获的对象 或 释放所使用的__block变量。
Block中使用的赋值给id类型的自动变量的对象 和 复制到堆上的__block变量由于被堆上的Block所持有,因而可超出其变量作用域而存在。
需要注意的是,若Block不复制到堆上,则其不会持有截获的对象。则对象会随着变量作用域结束而结束。
__block变量和对象
如前文所述,在Block中使用附有__strong修饰符的id类型或对象类型自动变量的情况下,当Block从栈复制到堆时,使用_Block_object_assign函数持有Block截获的对象。
当堆上的Block被废弃时,使用_Block_object_dispose函数释放Block截获的对象。
- 在__block变量为附有__strong修饰符的id类型或对象类型自动变量的情形下会发生同样的过程
当__block变量从栈复制到堆时,使用_Block_object_assign函数,持有赋值给__block变量的对象。
当堆上的__block变量被废弃时,使用_Block_object_dispose函数,释放赋值给__block变量的对象。
如:
__block id array = [NSMutableArray array];
blk_t blk = ^{
NSLog(@"%@",array);
};
blk();
会转换为:
struct __Block_byref_array_0 {
void *__isa;
__Block_byref_array_0 *__forwarding;
int __flags;
int __size;
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
id array;
};
static void __block__init_block_copy_0(struct __block__init_block_impl_0*dst, struct __block__init_block_impl_0*src) {_Block_object_assign((void*)&dst->array, (void*)src->array, 8/*BLOCK_FIELD_IS_BYREF*/);}
static void __block__init_block_dispose_0(struct __block__init_block_impl_0*src) {_Block_object_dispose((void*)src->array, 8/*BLOCK_FIELD_IS_BYREF*/);}
__block变量声明部分:
__attribute__((__blocks__(byref))) __Block_byref_array_0 array = {(void*)0,(__Block_byref_array_0 *)&array, 33554432, sizeof(__Block_byref_array_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, ((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("array"))};
简化为: __Block_byref_array_0 array = {
0,
&array,
33554432,
sizeof(__Block_byref_array_0),
__Block_byref_id_object_copy_131,
__Block_byref_id_object_dispose_131,
[[NSMutableArray alloc]init]
};
在Block中使用附有__weak修饰符的id类型变量会如何?如以下代码
blk_t blk;
{
id array = [NSMutableArray array];
id __weak array2 = array;
blk = ^(id obj){
[array2 addObject:obj];
NSLog(@"array2 count = %ld" ,[array2 count]);
};
}
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
输出结果为:
array2 count = 0
array2 count = 0
array2 count = 0
因为__strong修饰的变量array在该变量作用域结束的同时被释放、废弃,nil被赋值给变量array2。
即使在array2前面加上__block说明符,结果也是不变。因为array依旧会被释放废弃,依旧是nil赋值给array2
另外,使用___unsafe_unretained修饰符的变量只不过与指针相同,不会像__strong或__weak修饰符那样进行处理,因而通过悬垂指针访问已被废弃的对象程序会崩溃。
比如上述代码的__weak替换为__unsafe_unretained就会崩溃。
若一个变量obj同时指定__autoreleasing修饰符和__block说明符会引起编译错误,因为并没有设定__autoreleasing修饰符与Block同时使用的方法。
Block循环引用
因为写的人实在太多,所以不想过多讲述,简单提下吧。
如果在Block中使用附有__strong修饰符的对象类型自动变量,那么Block从栈复制到堆时,该对象为Block所持有。因而容易引起循环引用。
为避免此类事件,可用__weak修饰对象。
而在面向iOS4 与 OS Snow Leopard的应用程序中,必须使用__unsafe_unretained修饰符代替__weak。因为这个版本还没有__weak。
另外还可使用__block变量来避免循环引用,只要在Block语法中手动让__block修饰的对象置为nil即可,因此只要最少调用一次Block即可避免。
ARC无效时的copy / release
ARC无效时,需要手动将Block从栈复制到堆。此外,ARC无效时要手动释放复制的Block。使用copy实例方法来复制,用releas实例方法来释放。
只要Block有一次复制并配置在堆上,就可通过retain实例方法持有。若配置在栈上则retain实例方法不起任何作用。因此推荐用copy方法来持有。
由于Block是C语言的扩展,所以在C语言中也可以使用Block语法。此时用Block_copy函数 和 Block_release函数代替Copy / release实例方法,使用方法和引用计数的思考方式同OC中的copy / release实例方法:
Block_copy(blk)、Block_release(blk)
Block_copy函数就是之前提过的_Block_copy函数
ARC无效时,当Block从栈复制到堆时,若Block使用的变量为附有__block说明符的id类型或对象类型的自动变量,不会被retain。因此,ARC无效时__block说明符被用来Block中的循环引用。而若Block使用的变量为没有__block说明符的id类型或对象类型的自动变量,则无论ARC有效与否都会被retain。
参考文献:
Objective - C 高级编程:iOS与OS X多线程和内存管理