介紹
block實際上就是Objective-C語言對于閉包的實現(xiàn)。
block配合上dispatch_queue，可以方便地實現(xiàn)簡單的多線程編程和異步編程。
（閉包是一個函數(shù)（或指向函數(shù)的指針），再加上該函數(shù)執(zhí)行的外部的上下文變量（有時候也稱作自由變量）。）
block的寫法
回傳值(^名字)(參數(shù)列);
//聲明一個square的Block Pointer，其所指向的Block有一個int輸入和int輸出
int (^square)(int);
//將Block實體指定給square
square = ^(int a){ return a*a ; };
//調(diào)用方法，感覺是是不是很像function的用法？
int result = square(5);
NSLog(@"%d", result);
當其作為Object-C method的傳入值的話，需要把類型寫在變量前面，然后加上小括號。比如下面這種寫法：
//square參數(shù)的類型是int(^)(int)
-(void)objcMethod:(int(^)(int))square;
block陣列的使用
{
void (^blocks[3])(void);
for (NSInteger i = 0; i < 3; i++) {
blocks[i] = ^{
NSLog(@"Hello:%i", i);
};
}
blocks[0](); //result:Hello:0
blocks[1](); //result:Hello:1
blocks[2](); //result:Hello:2
}
存取變量
Block將使用到的、作用域附近的變量的值建立一份快照拷貝到棧上。
1、讀取和Block pointer同一個Scope的變量值：
{
int outA = 8;
int (^myPtr)(int) = ^(int a){ return outA + a;};
//block里面可以讀取同一類型的outA的值
int result = myPtr(3); // result is 11
NSLog(@"result=%d", result);
}
下面這一段代碼就不一樣了
{
int outA = 8;
int (^myPtr)(int) = ^(int a){ return outA + a;}; //block里面可以讀取同一類型的outA的值
outA = 5; //在調(diào)用myPtr之前改變outA的值
int result = myPtr(3); // result的值仍然是11，并不是8
NSLog(@"result=%d", result);
}
為什么result 的值仍然是11？而不是8呢？事實上，myPtr在其主體中用到的outA這個變量值的時候做了一個copy的動作，把outA的值copy下來，在Block中作為常量使用。所以，之后outA即使換成了新的值，對于myPtr里面copy的值是沒有影響的。（類似于深拷貝）
需要注意的是，這里copy的值是變量的值，如果它是一個記憶體的位置（地址），換句話說，就是這個變量是個指針的話，它的值是可以在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后，就變成{@"one", @"two"}了。
2、直接存取static類型的變量
因為全局變量或靜態(tài)變量在內(nèi)存中的地址是固定的，Block在讀取該變量值的時候是直接從其所在內(nèi)存讀出，獲取到的是最新值，而不是在定義時copy的常量。
{
static int outA = 8;
int (^myPtr)(int) = ^(int a){return outA + a;};
outA = 5;
int result = myPtr(3);
//result的值是8，因為outA是static類型的變量 (該變量在全局數(shù)據(jù)區(qū)分配內(nèi)存,但作用域還是局部作用域)
NSLog(@"result=%d", result);
}
3、Block Variable類型的變量
在某個變量前面如果加上修飾字“__block”的話（注意，block前面有兩個下劃線），這個變量就稱作block variable?；绢愋偷腂lock變量等效于全局變量、或靜態(tài)變量。
那么在block里面就可以任意修改此變量的值，如下代碼：
{
__block int num = 5;
int (^myPtr)(int) = ^(int a){return num++;};
int (^myPtr2)(int) = ^(int a){return num++;};
int result = myPtr(0); //result的值為5，num的值為6
result = myPtr2(0); //result的值為6，num的值為7
NSLog(@"result=%d", result);
}
4、weak–strong dance（避免循環(huán)引用）
- 使用方將self或成員變量加入block之前要先將self變?yōu)開_weak
- 在多線程環(huán)境下（block中的weakSelf有可能被析構(gòu)的情況下），需要先將self轉(zhuǎn)為strong指針，避免在運行到某個關鍵步驟時self對象被析構(gòu)。
以上兩條合起來有個名詞叫weak–strong dance
以下是使用weak–strong dance的經(jīng)典代碼
__weak __typeof(self)weakSelf = self和
__strong __typeof(weakSelf)strongSelf = weakSelf
//AFNetworking經(jīng)典代碼
__weak __typeof(self)weakSelf = self;
AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {
__strong __typeof(weakSelf)strongSelf = weakSelf;
strongSelf.networkReachabilityStatus = status;
if (strongSelf.networkReachabilityStatusBlock) {
strongSelf.networkReachabilityStatusBlock(status);
}
};
其中用到了__typeof(self)，這里涉及幾個知識點：
a. __typeof、__typeof__、typeof的區(qū)別
恩~~他們沒有區(qū)別，但是這牽扯一段往事，在早期C語言中沒有typeof這個關鍵字，__typeof、__typeof__是在C語言的擴展關鍵字的時候出現(xiàn)的。
typeof是現(xiàn)代GNU C++的關鍵字，從Objective-C的根源說，他其實來自于C語言，所以AFNetworking使用了繼承自C的關鍵字。
b.對于老的LLVM編譯器上面這句話會編譯報錯，所以在很早的ARC使用者中流行__typeof(&*self)這種寫法，原因如下
大致說法是老LLVM編譯器會將__typeof轉(zhuǎn)義為 XXX類名 const __strong的__strong和前面的__weak關鍵字對指針的修飾又沖突了，所以加上&對指針的修飾。
第四、五、六行，如果不轉(zhuǎn)成strongSelf而使用weakSelf，后面幾句話中，有可能在第四句執(zhí)行之后self的對象可能被析構(gòu)掉，然后后面的StausBlock沒有執(zhí)行，導致邏輯錯誤。
最后第五行，使用前對block判空。
//以下代碼是對__weak __typeof(self)weakSelf = self
//和__strong __typeof(weakSelf)strongSelf = weakSelf的宏定義
#ifndef weakify
#if DEBUG
#if __has_feature(objc_arc)
#define weakify(object) autoreleasepool{} __weak __typeof__(object) weak##_##object = object;
#else
#define weakify(object) autoreleasepool{} __block __typeof__(object) block##_##object = object;
#endif
#else
#if __has_feature(objc_arc)
#define weakify(object) try{} @finally{} {} __weak __typeof__(object) weak##_##object = object;
#else
#define weakify(object) try{} @finally{} {} __block __typeof__(object) block##_##object = object;
#endif
#endif
#endif
#ifndef strongify
#if DEBUG
#if __has_feature(objc_arc)
#define strongify(object) autoreleasepool{} __typeof__(object) object = weak##_##object;
#else
#define strongify(object) autoreleasepool{} __typeof__(object) object = block##_##object;
#endif
#else
#if __has_feature(objc_arc)
#define strongify(object) try{} @finally{} __typeof__(object) object = weak##_##object;
#else
#define strongify(object) try{} @finally{} __typeof__(object) object = block##_##object;
#endif
#endif
#endif
//使用方法
@weakify(self);
AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {
@strongify(self)
if(!self)return;
self.networkReachabilityStatus = status;
if (self.networkReachabilityStatusBlock) {
self.networkReachabilityStatusBlock(status);
}
};
避免循環(huán)引用
為什么會發(fā)生循環(huán)引用呢？
因為對象obj在Block被copy到堆上的時候自動retain了一次。因為Block不知道obj什么時候被釋放，為了不在Block使用obj前被釋放，Block retain了obj一次，在Block被釋放的時候，obj被release一次。
retain cycle問題的根源在于Block和obj可能會互相強引用，互相retain對方，這樣就導致了retain cycle，最后這個Block和obj就變成了孤島，誰也釋放不了誰。
