探讨Objective-C Block(3)

　　前面讲了简单的block用法跟block variable，

　　但是block难的地方应该就是记忆体管理的部份，

　　如果你不是很了解block内部的记忆体管理，

　　很容易一个不小心就导致circular reference而导致memory leakage..

　　前篇有提到，我们可以把block当作参数传给function或是message，

　　但是传进去后，有可能这个function会想把你的block pointer留下来

　　最常见的就是做event handling的例子，

　　我们把一个事件触发的block当作参数丢进来，

　　但是是件触发可能是数秒之后的事情，

　　而此时註event handler的function/message已经return了，

　　那此block所reference的local变数可能已经invalid了，

　　这时候block要怎么处理这样的情形呢?

　　首先，在block的定义中，此block还停留在call stack之中，

　　也就是他的生命週期会随着定义此block的function return之后，其生命週期就会结束

　　除非我们呼叫block_copy或是[myblock copy]

　　此时block才会从stack变到heap中。

　　之后我们才可以把参数传过来的block指给instance variable或是global variable，

　　而block中所用到的物件在此同时reference count也会+1。

　　但reference count +1这件事情却在每一种case不一样

　　因为block内部可以使用环境中看的到local, block, instance, local static, global variable

　　那copy这个动作会发生什么事情呢?

　　我们先写一个范例

　　//MyBlockTest.h

　　#import

　　typedef void (^myBlockTest_type)(void);

　　@interface MyBlockTest : NSObject {

　　NSObject* instanceRef;

　　myBlockTest_type myBlock;

　　}

　　- (void) test;

　　@end

　　//MyBlockTest.m

　　#import "MyBlockTest.h"

　　@implementation MyBlockTest

　　static NSObject* globalRef;

　　+(void) initialize

　　{

　　globalRef = [NSObject new];

　　}

　　- (id)init

　　{

　　self = [super init];

　　if(self)

　　{

　　instanceRef = [NSObject new];

　　}

　　return self;

　　}

　　- (void) test

　　{

　　// Local variable

　　NSObject* localRef = [NSObject new];

　　// Block variable

　　__block NSObject* blockRef = [NSObject new];

　　// Local static variable

　　static NSObject* localStaticRef;

　　if(!localStaticRef) localStaticRef = [NSObject new];

　　// create a block

　　myBlockTest_type aBlock =

　　^{

　　NSLog(@"%@", localRef);

　　NSLog(@"%@", blockRef);

　　NSLog(@"%@", instanceRef);

　　NSLog(@"%@", globalRef);

　　NSLog(@"%@", localStaticRef);

　　};

　　//copy the block

　　myBlock = [aBlock copy];

　　NSLog(@"%d", [localRef retainCount]);

　　NSLog(@"%d", [blockRef retainCount]);

　　NSLog(@"%d", [instanceRef retainCount]);

　　NSLog(@"%d", [globalRef retainCount]);

　　NSLog(@"%d", [localStaticRef retainCount]);

　　[localRef release];

　　}

　　@end

　　大家可以先想想看，当呼叫test的时候，会印出什么样的结果?

　　正确的答案是

　　2 1 1 1 1

　　不知道你答对了没?

　　第一个localRef应该最能够理解，基本上就是+1，这个就是这样设计。

　　第二个 blockRef，由前面一张对block variable的解释，

　　我们可以知道block variable是一个closure用一份。

　　因此此block variable并没有额外的retain的动作。

　　所以被block variable指到的物件也不会有reference count +1的情况。

　　第叁个instanceRef为什么没有+1呢?

　　事实上这个问题也是挺有陷阱题的味道。

　　对block来讲，他看到的是self这个变数，而非instanceRef。

　　所以ref. count +1的不是instanceRef而是self。

　　如果在block copy的前后各把self的ref count印出来你就可以佐证这个事实了。

　　第四个globalRef跟第五个localStaticRef本质上很像，所以两个可以一起讨论。

　　由于这两个变数在runtime中的位置是固定而且唯一的，

　　所以基本上在block内用上面两个变数跟block没有什么两样。

　　因此block copy并不会也不需要增加ref. count的数目。

　　了解之后，那什么时候可能会出现circular reference呢?

　　其实跟我们之前聊到的ios delegate你必须知道的事情所说的内容很像。

　　只是这次主角从delegate换成block。

　　试想，如果有3个view controller，分别是VC1, VC2, VC3

　　如果VC1产生并retain VC2

　　VC2也产生VC3

　　而且VC2可能跟VC3註册了一个event handler并且参数是用一个block。

　　在这个block中可能长这样。

　　[vc3 setOnClose:^{

　　[self dismissModalViewControllerAnimated:YES];

　　}];

　　那这样会发生什么是情呢?

　　答案是当VC1 release VC2的时候，

　　VC2因为自己有参照VC3，所以VC3的retain count还是1

　　VC3因为他的instance variable有retain这个block

　　而这个block因为用到block中的self

　　这个self就是VC2，

　　那这样可糟了个糕，circular的悲剧就产生了。

　　目前官方文件告诉我们要这样做

　　__block VC2* tempVC2 = self;

　　[vc3 setOnClose:^{

　　[tempVC2 dismissModalViewControllerAnimated:YES];

　　}];

　　我们透过block variable不会retain的特性，

　　来把self丢给tempVC2，

　　如此在block在被copy的时候不会增加retain count。

　　我只能说太不friendly了，

　　不过目前好像也只有这样解，而且到了ARC之后这个问题还是存在。

　　所以大家一定要改清楚block的memory management，

　　才不会不知道为什么，reference count永远不会归零的状况。