[Cocoa]深入淺出 Cocoa 多線程程式設計之 block 與 dispatch quene

深入淺出 Cocoa 多線程程式設計之 block 與 dispatch quene 羅朝輝(http://blog.csdn.net/kesalin CC 許可，轉載請注明出處

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, const 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 修飾的變量。請看：

__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);

相似的情況，我們也可以引用 static block 或 __block block。比如我們可以用他們來實作 block 遞歸：

// 1
    void (^aBlock)(int) = 0;
    static void (^ const 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);

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[i];
        
        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(const 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[i];
        
        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[i];
        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[i];
        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;
    
    // iterations
    //
    dispatch_apply(Length, queue, ^(size_t i) {
        sum += pArray[i];
    });
    
    NSLog(@" >> sum: %d", sum);

    dispatch_release(queue);

    [pool drain];

注意這裡使用了全局 dispatch_queue。

dispatch_apply 的定義如下：

dispatch_apply(size_t iterations, dispatch_queue_t queue, void (^block)(size_t));

參數 iterations 表示疊代的次數，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[i];
        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[i];
        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 并行程式設計相關基本知識，開始在項目中運用它們吧，

參考資料：

Concurrency Programming Guide：

http://developer.apple.com/library/ios/#documentation/General/Conceptual/ConcurrencyProgrammingGuide/Introduction/Introduction.html

[Cocoa]深入淺出 Cocoa 多線程程式設計之 block 與 dispatch quene

繼續閱讀

【觀點】風雨20年：我所積累的20條程式設計經驗【觀點】風雨20年：我所積累的20條程式設計經驗

【轉載】風雨20年：我所積累的20條程式設計經驗

如果你的夢想是成為一名程式員，那可能需要看看這篇文章！

python兩種方法解決線程沖突問題線程沖突起因解決方案

寫在工作13周年

程式設計高手：VC 6.0下利用消息實作内部程序通訊

VS2008 不在支援 Attributed ATL

C++之父Bjarne Stroustrup的演講：軟體理想和曆史

linux網絡程式設計----發送與接收檔案

各種二分查找

JAVA高效程式設計指南

swift資料合集

C++ 多線程用條件變量确定線程的執行順序而不是使用 sleep(1)

C#多線程——前台線程和背景線程

線程同步，可重入鎖，synchronized

C++ 第十五周報告1--《冒泡法排序》