block

参考：http://o0o0o0o.iteye.com/blog/1316714

以下引自：http://mobile.51cto.com/iphone-279757.htm

Apple有一個叫做GCD(Grand Central Dispach)的新功能，用在同步處理(concurrency)的環境下有更好的效率。Block語法產生的動機就是來自於GCD，用Block包好一個工作量交給GCD，GCD有一個宏觀的視野可以來分配CPU，GPU，Memory的來下最好的決定。

block 声明：int (^square) (int);  定义：square = ^(int a){ return a * a;};

调用：square(5); 或者：不用block point直接：^(int a){ return a * a} (5);

object这样定义：

- (void) objectMethod:(int (^) (int) ) square;

读取外部变量

1. {  
2. int outA = 8;  
3. int (^myPtr) (int) = ^(int a) {return outA+a;};  
4. // block 裡面可以讀同一個scope的outA的值  
5. int result = myPtr(3); // result is 11  
6. } 

 
 
{  
int outA = 8;  
int (^myPtr) (int) = ^(int a) {return outA+a;};  
// block 裡面可以讀同一個scope的outA的值  
outA = 5; // 在呼叫myPtr之前改變outA的值  
int result = myPtr(3); // result 的值還是 11並不是 8  
} 

事實上呢，myPtr在其主體用到outA這個變數值的時候是做了一個copy的動作把outA的值copy下來。所以之後outA即使換了新的值對於myPtr裡copy的值是沒有影響到的。

要注意的是，這個指的值是變數的值，如果這個變數的值是一個記憶體的位置，換句話說，這個變數是個pointer的話，它指到的值是可以在block裡被改變的。

 
 
{  
        NSMutableArray * mutableArray = [NSMutableArray arrayWithObjects:@"one",@"two",@"three",nil];  
        int result = ^(int a) { [mutableArray removeLastObject];  return a*a;} (5);  
        NSLog(@"test array %@", mutableArray);  
} 

原本mutableArray的值是{@"one",@"two",@"three"}在block裡被更改mutableArray所指向的物件後，mutableArray的值就會被成{@"one",@"two"}

3. Block Variable

在某個變數前面如果加上修飾字__block 的話(注意block前有兩個下底線)，這個變數又稱為block variable。那麼在block裡就可以任意修改此變數值，變數值的改變也可以知道。

 
 
{  
    __block int num = 5;  
 
    int (^myPtr) (int) = ^(int a) { return num++;};  
    int (^myPtr2) (int) = ^(int a) { return num++;};  
    int result = myPtr(0);  
    result = myPtr2(0);  
} 

因為myPtr和myPtr2都有用到num這個block variable，最後result的值就會是7

生命周期和記憶體管理

因為block也是繼承自NSObject，所以其生命周期和記憶體的管理也就非常之重要。

block一開始都是被放到stack裡，換句話說其生命周期隨著method或function結束就會被回收，和一般變數的生命周期一樣。

關於記憶體的管理請遵循這幾個要點

1. block pointer的實體會在method或function結束後就會被清掉

2. 如果要保存block pointer的實體要用-copy指令，這樣block pointer就會被放到heap裡

（1）block 主體裡用到的block variable 也會被搬到heap 而有新的記憶體位置，且一並更新有用到這個block variable 的block都指到新的位置
    
（2）一般的variable值會被copy 
    
（3）如果主體裡用到的variable是object的話，此object會被retain, block release時也會被release
    
（4）block variable 裡用到的object是不會被retain的

首先來看一下這個例子

 
 
typedef int (^MyBlock)(int);  
 
MyBlock genBlock();  
 
int main(){  
        MyBlock outBlock = genBlock();  
        int result = outBlock(5);  
 
        NSLog(@"result is %d",[outBlock retainCount] ); // segmentation fault  
        NSLog(@"result is %d",result  );  
 
        return 0 ;  
}  
MyBlock genBlock() {  
        int a = 3;  
        MyBlock inBlock = ^(int n) {  
                return n*a;  
        };  
        return inBlock ;  
} 

此程式由genBlock裡產生的block再指定給main function的outBlock變數，執行這個程式會得到

 
 
Segmentation fault 

(註：有時候把 genBlock裡的a 去掉就可以跑出結果的情形，這是系統cache住記憶體，並不是inBlock真得一直存在，久了還是會被回收，千萬不要以為是對的寫法)
表示我們用到了不該用的記憶體，在這個例子的情況下是在genBlock裡的inBlock變數在return的時候就被回收了，outBlock無法有一個合法的記憶體位置-retainCount就沒意義了。

如果這個時候需要保留inBlock的值就要用-copy指令，將genBlock改成

 
 
 MyBlock genBlock() {  
        int a = 3;  
        MyBlock inBlock = ^(int n) {  
                return n*a;  
        };  
        return [inBlock copy]  ;  
} 

這樣[inBlock copy]的回傳值就會被放到heap，就可以一直使用(記得要release)

執行結果是

 
 
result is 1  
result is 15 

再次提醒要記得release outBlock。

如果一回傳[inBlock copy]的值就不再需要的時候可以這樣寫

 
 
 MyBlock genBlock() {  
        int a = 3;  
        MyBlock inBlock = ^(int n) {  
                return n*a;  
        };  
        return [[inBlock copy] autorelease] ;  
} 

-copy指令是為了要把block 從stack搬到heap，autorelease是為了平衝retainCount加到autorelease oop ，回傳之後等到事件結束就清掉。

接下來是block存取到的local variable是個物件的型別，然後做copy 指令時

 
 
MyBlock genBlock() {  
        int a = 3;  
        NSMutableString * myString = [NSMutableString string];  
        MyBlock inBlock = ^(int n) {  
                NSLog(@"retain count of string %d",[myString retainCount]);  
                return n*a;  
        };  
        return [inBlock copy] ;  
} 

結果會印出

 
 
retain count of string 2 

這個結果和上面2.3提到的一樣，local variable被retain了

那再來試試2.4，在local variable前面加上__block

 
 
MyBlock genBlock() {  
        int a = 3;  
        __block NSMutableString * myString = [NSMutableString string];  
        MyBlock inBlock = ^(int n) {  
                NSLog(@"retain count of string %d",[myString retainCount]);  
                return n*a;  
        };  
        return [inBlock copy] ;  
} 

執行的結果就是會

 
 
retain count of string 1

Block Copying注意事項

如果在Class method裡面做copying block動作的話

1. 在Block裡如果有直接存取到self，則self會被retain

2. 在Block裡如果取存到instance variable (無論直接或是從accessor)，則self會被retain

3. 取存到local variable所擁有的object時，這個object會被retain

讓我們來看一個自訂的Class

 
 
@interface MyObject : NSObject {  
        NSString * title;  
        void (^myLog) (NSString * deco);  
}  
 
-(void) logName;  
@end  
@implementation MyObject  
-(id) initWithTitle:(NSString * ) newTitle{  
        if(self = [super init]){  
                title = newTitle;  
                myLog = [^(NSString * deco) { NSLog(@"%@%@%@",deco, title, deco );} copy];  
        }  
        return self;  
}  
 
-(void) logName{  
 myLog(@"==");  
}  
 
-(void ) dealloc{  
 
        [myLog release];  
        [title release];  
        [super dealloc];  
}  
@end 

在main 裡使用如下

 
 
MyObject * mObj = [[MyObject alloc] initWithTitle:@"Car"];  
NSLog(@"retainCount of MyObject is  %d",[mObj retainCount]  );  
[mObj logName]; 

其執行的結果為

 
 
retainCount of MyObject is  2 
==Car== 

因為在MyObject的建構子裡myLog這個block pointer用了title這個instance variable然後就會retain self也就是MyObject的物件。

盡量不要這樣寫，會造成retain cycle，改善的方法是把建構子改成這樣

 
 
-(id) initWithTitle:(NSString * ) newTitle{  
        if(self = [super init]){  
                title = newTitle;  
                myLog = [^(NSString * deco) { NSLog(@"%@%@%@",deco, newTitle, deco );} copy];  
        }  
        return self;  
} 

在Block主體裡用newTitle這個變數而不是title。這樣self就不會被retain了。

最後談一個小陷井

 
 
void (^myLog) (void);   
BOOL result ;  
if(result)  
    myLog = ^ {NSLog(@"YES");};  
 
else  
    myLog = ^ {NSLog(@"NO");};  
 
myLog(); 

這樣很可能就會當掉了，因為myLog 實體在if 或是else結束後就被清掉了。要記得。

要用copy來解決這個問題，但要記得release