Cocoa 多線程編程之 block 與 dispatch quene

block 是 Apple 在 GCC 4.2 中擴充的新語法特性，其目的是支持多核並行編程。咱們能夠將 dispatch_queue 與 block 結合起來 使用，方便進行多線程編程。

1，實驗工程準備
在 XCode 4.0 中，咱們創建一個 Mac OS X Application 類型的 Command Line Tool，在 Type 裏面咱們選擇 Foundation 就好，工程名字暫且爲 StudyBlocks.默認生成的工程代碼 main.m 內容以下：
int main (int argc, c*****t char * argv[])
{
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

    // insert code here
    NSLog(@"Hello, World!");

    [pool drain];
    return 0;
}


2，如何編寫 block
在自動生成的工程代碼中，默認打印一條語句"Hello, World!"，這個任務能夠不能夠用 block 語法來實現呢？答案是確定的，請看：
    void (^aBlock)(void) = ^(void){ NSLog(@"Hello, World!"); };
    aBlock();

用上面的這兩行語句替換 main.m 中的 NSLog(@"Hello, World!"); 語句，編譯運行，結果是同樣的。
這 兩行語句是什麼意思呢？首先，等號左邊的 void (^aBlock)(void) 表示聲明瞭一個 block，這個 block 不帶參數(void)且也無返回參數(void)；等號右邊的 ^(void){ } 結構表示一個 block 的實現體，至於這個 block 具體要作的事情就都在 {} 之間了。在這裏咱們僅僅是打印一條語句。整個語句就是聲明一個 block，並對其賦值。第二個語句就是調用這個 block 作實際的事情，就像咱們調用函數同樣。block 頗有點像 C++0X 中的 Lambda 表達式。
咱們也能夠這麼寫：
    void (^aBlock)(void) = 0;
    aBlock = ^(void) {
        NSLog(@"Hello, World!");
    };

    aBlock();

如今咱們知道了一個 block 該如何編寫了，那麼 block 數組呢？也很簡單，請看：
    void (^blocks[2])(void) = {
        ^(void){ NSLog(@" >> This is block 1!"); },
        ^(void){ NSLog(@" >> This is block 2!"); }
    };
    
    blocks[0]();
    blocks[1]();


謹記！
block 是分配在 stack 上的，這意味着咱們必須當心裏處理 block 的生命週期。
好比以下的作法是不對的，由於 stack 分配的 block 在 if 或 else 內是有效的，可是到大括號 } 退出時就可能無效了：
   dispatch_block_t block;
  
   if (x) {
       block = ^{ printf("true\n"); };
   } else {
       block = ^{ printf("false\n"); };
   }
   block();

上面的代碼就至關於下面這樣的 unsafe 代碼：
   if (x) {
       struct Block __tmp_1 = ; // setup details
       block = &__tmp_1;
   } else {
       struct Block __tmp_2 = ; // setup details
       block = &__tmp_2;
   }


3，如何在 block 中修改外部變量
考慮到 block 的目的是爲了支持並行編程，對於普通的 local 變量，咱們就不能在 block 裏面隨意修改（緣由很簡單，block 能夠被多個線程並行運行，會有 問題的），並且若是你在 block 中修改普通的 local 變量，編譯器也會報錯。那麼該如何修改外部變量呢？有兩種辦法，第一種是能夠修改 static 全局變量；第二種是能夠修改用新關鍵字 __block 修飾的變量。請看：
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    
    __block int blockLocal  = 100;
    static int staticLocal  = 100;
    
    void (^aBlock)(void) = ^(void){
        NSLog(@" >> Sum: %d\n", global + staticLocal);
        
        global++;
        blockLocal++;
        staticLocal++;
    };
    
    aBlock();

    NSLog(@"After modified, global: %d, block local: %d, static local: %d\n", global, blockLocal, staticLocal);

    [pool drain];

執行以後，值均爲：101

類似的狀況，咱們也能夠引用 static block 或 __block block。好比咱們能夠用他們來實現 block 遞歸：
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    
    // 1
    void (^aBlock)(int) = 0;
    static void (^ c*****t staticBlock)(int) = ^(int i) {
        if (i > 0) {
            NSLog(@" >> static %d", i);
            staticBlock(i - 1);
        }
    };
    
    aBlock = staticBlock;
    aBlock(5);
    
    // 2
    __block void (^blockBlock)(int);
    blockBlock = ^(int i) {
        if (i > 0) {
            NSLog(@" >> block %d", i);
            blockBlock(i - 1);
        }
    };
    
    blockBlock(5);
    
    [pool drain];


4，上面咱們介紹了 block 及其基本用法，但尚未涉及並行編程。 block 與 Dispatch Queue 分發隊列結合起來使用，是 iOS 中並行編程的利器。請看代碼：
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    
    initData();
    
    // create dispatch queue
    //
    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);
        
        flag = YES;
    });
    
    // wait util work is done.
    //
    while (!flag);
    dispatch_release(queue);
    
    [pool drain];


上 面的 block 僅僅是將數組求和。首先，咱們建立一個串行分發隊列，而後將一個 block 任務加入到其中並行運行，這樣 block 就會在新的線程中運行，直到結束返回主線程。在這裏要注意 flag 的使用。flag 是 static 的，因此咱們能夠 block 中修改它。 語句 while (!flag); 的目的是保證主線程不會 blcok 所在線程以前結束。
dispatch_queue_t 的定義以下：
typedef void (^dispatch_block_t)( void);
這意味着加入 dispatch_queue 中的 block 必須是無參數也無返回值的。

dispatch_queue_create 的定義以下：
dispatch_queue_t dispatch_queue_create(c*****t char *label, dispatch_queue_attr_t attr);
這個函數帶有兩個參數：一個用於標識 dispatch_queue 的字符串；一個是保留的 dispatch_queue 屬性，將其設置爲 NULL 便可。

咱們也可使用
dispatch_queue_t dispatch_get_global_queue(long priority, unsigned long flags);
來得到全局的 dispatch_queue，參數 priority 表示優先級，值得注意的是：咱們不能修改該函數返回的 dispatch_queue。
dispatch_async 函數的定義以下：
void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
它是將一個 block 加入一個 dispatch_queue，這個 block 會再其後獲得調度時，並行運行。
相應的 dispatch_sync 函數就是同步執行了，通常不多用到。好比上面的代碼若是咱們修改成 dispatch_sync，那麼就無需編寫 flag 同步代碼了。

5，dispatch_queue 的運做機制及線程間同步
我 們能夠將許多 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];

首 先咱們建立一個 __block semaphore，並將其資源初始值設置爲 0 (不能少於 0)，在這裏表示任務尚未完成，沒有資源可用主線程不要作事情。而後在 block 任務完成以後，使用 dispatch_semaphore_signal 增長 semaphore 計數（可理解爲資源數），代表任務完成，有資源可用主線程能夠作事情了。而主線程中的 dispatch_semaphore_wait 就是減小 semaphore 的計數，若是資源數少於 0，則代表資源還可不得，我得按照FIFO（先等先得）的規則等待資源就緒，一旦資源就緒而且獲得調度了，我再執行。
6 示例：
下面咱們來看一個按照 FIFO 順序執行並用 semaphore 同步的例子：先將數組求和再依次減去數組。
    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 才能幹正事。 這樣咱們就能夠保證先求和，再相減，而後再讓主線程運行結束這個順序。
7，使用 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;
    
    // iterati*****
    //
    dispatch_apply(Length, queue, ^(size_t i) {
        sum += pArray;
    });
    
    NSLog(@" >> sum: %d", sum);

    dispatch_release(queue);

    [pool drain];

注意這裏使用了全局 dispatch_queue。
dispatch_apply 的定義以下：
dispatch_apply(size_t iterati*****, dispatch_queue_t queue, void (^block)(size_t));
參數 iterati***** 表示迭代的次數，void (^block)(size_t) 是 block 循環體。這麼作與 for 循環相比有什麼好處呢？答案是：並行，這裏的求和是並行的，並非按照順序依次執行求和的。
8, 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 並行編程相關基本知