如何在 block 中修改外部變量?????
考慮到 block 的目的是為了支持並行編程，對於普通的 local 變量，我們就不能在 block 里面隨意修改（原因很簡單，block 可以被多個線程並行運行，會有 問題 的），而且如果你在 block 中修改普通的 local 變量，編譯器也會報錯。那么該如何修改外部變量呢？有兩種辦法，第一種是可以修改 static 全局變量；第二種是可以修改用新關鍵字 __block 修飾的變量。
__block關鍵字
一個Block的內部是可以引用自身作用域外的變量的，包括static變量，extern變量或自由變量（定義一個變量的時候，如果不加存儲修飾符，默認情況下就是自由變量auto,auto變量保存在stack中的，除了auto之外還存在register,static等存儲修飾符），
對於局部變量，在block中是只讀的。在引入block的同時，還引入了一種特殊的關鍵字__block，用此聲明一個局部變量可以被函數塊修改。
實例：
void(^aBlock)(void) = 0; // 聲明一個block
aBlock = ^(void){ // 給block賦值
NSLog(@"this is a block.");
};
aBlock(); // 執行block
上面我們介紹了 block 及其基本用法，但還沒有涉及並行編程。 block 與 Dispatch Queue 分發隊列結合起來使用，是 iOS 中並行編程的利器。
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc]init];
// 創建一個串行分發隊列
dispatch_queue_t queue = dispatch_queue_create("studyBlocks", NULL);
// 將一個 block 任務加入到其中並行運行. 這樣 block 就會在新的線程中運行，直到結束返回主線程
// 加入 dispatch_queue 中的 block 必須是無參數也無返回值的
dispatch_async(queue, ^(void){
int sum = 0;
for (int i = 0; i<100; i++) {
sum += i;
}
NSLog(@"sum:%d",sum);
});
dispatch_release(queue);
[pool drain];
1、dispatch_queue_t 類型 的定義如下：
typedef void (^dispatch_block_t)( void);
這意味着加入 dispatch_queue 中的 block 必須是無參數也無返回值的。
dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);
該 函數 創建分發隊列 dispatch_queue。 帶有兩個參數：一個用於標識 dispatch_queue 的字符串；一個是保留的 dispatch_queue 屬性，將其設置為 NULL 即可。
來獲得全局的 dispatch_queue，參數 priority 表示優先級，值得注意的是：我們不能修改該函數返回的 dispatch_queue。例如：
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[[[self captureManager] session] startRunning];
});
void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
該函數將一個 block 加入一個 dispatch_queue，這個 block 會再其后得到調度時，並行運行。
相應的 dispatch_sync 函數就是同步執行了，一般很少用到。比如上面的代碼如果我們修改為 dispatch_sync，那么就無需編寫 flag 同步代碼了。
我們可以將許多 blocks 用 dispatch_async 函數提交到到 dispatch_queue 串行運行。這些 blocks 是按照 FIFO(先入先出)規則調度的，也就是說，先加入的先執行，后加入的一定后執行，但在某一個時刻，可能有多個 block 同時在執行。
在上面的例子中，我們的主線程一直在輪詢 flag 以便知曉 block 線程是否執行完畢，這樣做的效率是很低的，嚴重浪費 CPU 資源。我們可以使用一些通信機制來解決這個問題，如：semaphore（信號量）。 semaphore 的原理很簡單，就是生產-消費模式，必須生產一些資源才能消費，沒有資源的時候，那我就啥也不干，直到資源就緒。
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
initData();
// Create a semaphore with 0 resource
__block dispatch_semaphore_t sem = dispatch_semaphore_create(0);
// create dispatch semaphore
dispatch_queue_t queue = dispatch_queue_create("StudyBlocks", NULL); dispatch_async(queue, ^(void) {int sum = 0;
for(int i = 0; i < Length; i++)
sum += data;
NSLog(@" >> Sum: %d", sum);// signal the semaphore: add 1 resource
dispatch_semaphore_signal(sem);});
// wait for the semaphore: wait until resource is ready.
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
dispatch_release(sem);
dispatch_release(queue);
[pool drain];
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
initData();
__block int sum = 0;
// Create a semaphore with 0 resource
__block dispatch_semaphore_t sem = dispatch_semaphore_create(0);
__block dispatch_semaphore_t taskSem = dispatch_semaphore_create(0);
// create dispatch semaphore
dispatch_queue_t queue = dispatch_queue_create("StudyBlocks", NULL);
dispatch_block_t task1 = ^(void) {
int s = 0;
for (int i = 0; i < Length; i++)
s += data;
sum = s;
NSLog(@" >> after add: %d", sum);
dispatch_semaphore_signal(taskSem);
};
dispatch_block_t task2 = ^(void) {
dispatch_semaphore_wait(taskSem, DISPATCH_TIME_FOREVER);
int s = sum;
for (int i = 0; i < Length; i++)
s -= data;
sum = s;
NSLog(@" >> after subtract: %d", sum);
dispatch_semaphore_signal(sem);
};
dispatch_async(queue, task1);
dispatch_async(queue, task2);
// wait for the semaphore: wait until resource is ready.
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
dispatch_release(taskSem);
dispatch_release(sem);
dispatch_release(queue);
[pool drain];
在上面的代碼中，我們利用了 dispatch_queue 的 FIFO 特性，確保 task1 先於 task2 執行，而 task2 必須等待直到 task1 執行完畢才開始干正事，主線程又必須等待 task2 才能干正事。 這樣我們就可以保證先求和，再相減，然后再讓主線程運行結束這個順序。
使用 dispatch_apply 進行並發迭代：
對於上面的求和操作，我們也可以使用 dispatch_apply 來簡化代碼的編寫.
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
initData();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
__block int sum = 0;
__block int *pArray = data;
// iterations
//
dispatch_apply(Length, queue, ^(size_t i) {
sum += pArray;
});
NSLog(@" >> sum: %d", sum);
dispatch_release(queue);
[pool drain];
dispatch group
我們可以將完成一組相關任務的 block 添加到一個 dispatch group 中去，這樣可以在 group 中所有 block 任務都完成之后，再做其他事情。比如 6 中的示例也可以使用 dispatch group 實現：
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
initData();
__block int sum = 0;
// Create a semaphore with 0 resource
//
__block dispatch_semaphore_t taskSem = dispatch_semaphore_create(0);
// create dispatch semaphore
//
dispatch_queue_t queue = dispatch_queue_create("StudyBlocks", NULL);
dispatch_group_t group = dispatch_group_create();
dispatch_block_t task1 = ^(void) {
int s = 0;
for (int i = 0; i < Length; i++)
s += data;
sum = s;
NSLog(@" >> after add: %d", sum);
dispatch_semaphore_signal(taskSem);
};
dispatch_block_t task2 = ^(void) {
dispatch_semaphore_wait(taskSem, DISPATCH_TIME_FOREVER);
int s = sum;
for (int i = 0; i < Length; i++)
s -= data;
sum = s;
NSLog(@" >> after subtract: %d", sum);
};
// Fork
dispatch_group_async(group, queue, task1);
dispatch_group_async(group, queue, task2);
// Join
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
dispatch_release(taskSem);
dispatch_release(queue);
dispatch_release(group);
[pool drain];
在上面的代碼中，我們使用 dispatch_group_create 創建一個 dispatch_group_t，然后使用語句：dispatch_group_async(group, queue, task1)將 block 任務加入隊列中，並與組關聯，這樣我們就可以使用 dispatch_group_wait(group, DISPATCH_TIME_FOREVER)來等待組中所有的 block 任務完成再繼續執行。
至此我們了解了 dispatch queue 以及 block 並行編程相關基本知識，開始在項目中運用它們吧。