Blocks與Dispatch Queue的使用

block是什麼
block是一個C level的語法以及運行時的一個特性，和標準C中的函數（函數指針）相似。用於回調函數的地方。兩個對象間的通信。實現輕量級的「代理」。


blocks和C語言函數指針的區別

 

如何調用blocks
調用block和C語言函數指針的調用如出一轍

 

 
如何在 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];

一、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 的字符串；一個是保留的 dispatch_queue 屬性，將其設置爲 NULL 便可。

三、也可以使用函數 dispatch_queue_t dispatch_get_global_queue(long priority, unsigned long flags);
來得到全局的 dispatch_queue，參數 priority 表示優先級，值得注意的是：咱們不能修改該函數返回的 dispatch_queue。例如：

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

[[[self captureManager] session] startRunning];

});

四、dispatch_async 函數的定義以下：
void  dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
該函數將一個 block 加入一個 dispatch_queue，這個 block 會再其後獲得調度時，並行運行。
相應的 dispatch_sync 函數就是同步執行了，通常不多用到。好比上面的代碼若是咱們修改成 dispatch_sync，那麼就無需編寫 flag 同步代碼了。

五、dispatch_block_t 類型

dispatch_block_t

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];

一、dispatch_semaphore_create函數

此函數用於建立一個 __block semaphore，這裏將其資源初始值設置爲 0 (不能少於 0)，表示任務尚未完成，沒有資源可用主線程不要作事情。

二、dispatch_semaphore_signal函數

該函數  增長 semaphore 計數（可理解爲資源數），代表任務完成，有資源可用主線程能夠作事情了。

三、dispatch_semaphore_wait函數

主線程中的 dispatch_semaphore_wait 就是 減小 semaphore 的計數，若是資源數少於 0，則代表資源還可不得，我得按照FIFO（先等先得）的規則等待資源就緒，一旦資源就緒而且獲得調度了，我再執行。

下面咱們來看一個按照 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 才能幹正事。 這樣咱們就能夠保證先求和，再相減，而後再讓主線程運行結束這個順序。

使用 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_queue。

dispatch_apply 的定義以下：

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

參數 iterations 表示迭代的次數，void (^block)(size_t) 是 block 循環體。這麼作與 for 循環相比有什麼好處呢？答案是：並行，這裏的求和是並行的，並非按照順序依次執行求和的。

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 並行編程相關基本知識，開始在項目中運用它們吧。