深刻淺出 Cocoa 多線程編程之 block 與 dispatch quene

時間 2019-11-17

標籤深刻 cocoa 多線程編程 block dispatch quene 欄目 Java 简体版

原文原文鏈接

羅朝輝(http://www.cppblog.com/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 修飾的變量。請看：

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 ( ^ 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 );

    [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[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