您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 使用技巧 >> iOS 技巧大全

對 GCD 的理解與實踐:任務、隊列、屏障與死鎖

編輯:iOS 技巧大全

GCD 是什麼

GCD 全稱 Grand Central Dispatch,是蘋果為多核並行場景提出的解決方案。它用 C 語言實現,但借助 block 處理回調,寫起來非常順手。更重要的是,它會自動管理線程的生命週期,開發者不需要手動維護線程池。

兩個核心概念:任務與隊列

任務是我們想執行的事情,分為同步和異步兩種:

同步(sync)通過 dispatch_sync(dispatch_queue_t queue, dispatch_block_t block) 創建。它會阻塞當前線程,等 block 執行完畢返回後才繼續往下走。

異步(async)通過 dispatch_async(dispatch_queue_t queue, dispatch_block_t block) 創建。它不會阻塞當前線程,任務提交後立即返回。

隊列存放任務,並以先入先出的方式派發,分為串行與並行兩類:

串行隊列(Serial queue)嚴格按提交順序執行,必須等上一個任務完成才啟動下一個。

並行隊列(Concurrent queue)按提交順序把任務派發出去,讓它們並行執行。不過要注意,GCD 會根據系統資源自動控制並發數量,任務再多也不會一次性全部開跑。

兩者組合的結果可以一張表概括:

                串行隊列                    並行隊列
同步執行任務     當前線程,一個一個執行        當前線程,一個一個執行
異步執行任務     另開線程,一個一個執行        開多條線程,一起執行

下面的示例直觀地呈現了這幾種組合:

dispatch_queue_t serial_queue = dispatch_queue_create("serial.queue", DISPATCH_QUEUE_SERIAL);
// 主隊列
dispatch_queue_t mainQueue = dispatch_get_main_queue();

dispatch_queue_t concurrent_queue = dispatch_queue_create("concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
// 全局隊列
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 串行隊列 + 同步:在主線程順序執行
dispatch_sync(serial_queue, ^{ NSLog(@"task a ,thread:%@",[NSThread currentThread]); });
dispatch_sync(serial_queue, ^{ NSLog(@"task b ,thread:%@",[NSThread currentThread]); });
dispatch_sync(serial_queue, ^{ NSLog(@"task c ,thread:%@",[NSThread currentThread]); });

// 串行隊列 + 異步:另開一條線程,順序執行
dispatch_async(serial_queue, ^{ NSLog(@"task 1 ,thread:%@",[NSThread currentThread]); });
dispatch_async(serial_queue, ^{ NSLog(@"task 2 ,thread:%@",[NSThread currentThread]); });
dispatch_async(serial_queue, ^{ NSLog(@"task 3 ,thread:%@",[NSThread currentThread]); });

// 並行隊列 + 異步:開多條線程同時執行
dispatch_async(concurrent_queue, ^{ NSLog(@"task 11 ,thread:%@",[NSThread currentThread]); });
dispatch_async(concurrent_queue, ^{ NSLog(@"task 22 ,thread:%@",[NSThread currentThread]); });
dispatch_async(concurrent_queue, ^{ NSLog(@"task 33 ,thread:%@",[NSThread currentThread]); });

任務組與柵欄

需要為多個任務建立依賴關係時,可以用任務組 dispatch_group 和柵欄 dispatch_barrier。

任務組把若干任務放進同一個 group,這些任務可以在同一隊列,也可以分佈在不同隊列,之後用 dispatch_group_notify() 或 dispatch_group_wait() 統一處理完成時機。

1. dispatch_group_notify() 中的任務會在 group 內所有任務完成後執行:

dispatch_group_t group = dispatch_group_create();

dispatch_group_async(group, serial_queue, ^{ sleep(2); NSLog(@"serial_queue1"); });
dispatch_group_async(group, serial_queue, ^{ sleep(2); NSLog(@"serial_queue2"); });
dispatch_group_async(group, concurrent_queue, ^{ sleep(2); NSLog(@"concurrent_queue1"); });

dispatch_group_notify(group, dispatch_get_main_queue(), ^{ NSLog(@"return main queue"); });

2. dispatch_group_wait() 可以傳入一個超時時間。若在等待時間結束前 group 內所有任務完成則返回 0,否則返回非 0。它本身就是一個同步阻塞調用:

dispatch_group_async(group, serial_queue, ^{ sleep(3); NSLog(@"serial_queue1"); });
dispatch_group_async(group, serial_queue, ^{ sleep(2); NSLog(@"serial_queue2"); });
dispatch_group_async(group, concurrent_queue, ^{ sleep(3); NSLog(@"concurrent_queue1"); });

long i = dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 6));
NSLog(@"-- %ld --", i);

dispatch_group_async(group, concurrent_queue, ^{ NSLog(@"finish all"); });

3. dispatch_group_enter() / dispatch_group_leave() 可以動態往任務組裡添加任務。兩者必須成對出現,夾在中間的代碼就是待加入的任務:

dispatch_group_enter(group);
sleep(2);
NSLog(@"1");
dispatch_group_leave(group);

dispatch_group_enter(group);
dispatch_async(concurrent_queue, ^{
    sleep(3);
    NSLog(@"2");
    dispatch_group_leave(group);
});

dispatch_group_enter(group);
sleep(2);
NSLog(@"3");
dispatch_group_leave(group);

long i = dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 6));
NSLog(@"-- %ld --", i);

dispatch_group_async(group, concurrent_queue, ^{ NSLog(@"finish all"); });

柵欄的作用是把隊列中的任務切成兩段:柵欄之前提交的任務全部執行完畢後,柵欄任務會獨佔執行,完成後才繼續跑後面的任務。由於柵欄必須單獨執行、不能與其他任務並發,所以 dispatch_barrier 只對並發隊列有意義。

dispatch_queue_t concurrent_queue = dispatch_queue_create("concurrent.queue", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(concurrent_queue, ^{ sleep(2); NSLog(@"1"); });
dispatch_async(concurrent_queue, ^{ sleep(2); NSLog(@"2"); });
dispatch_async(concurrent_queue, ^{ sleep(2); NSLog(@"3"); });

dispatch_barrier_async(concurrent_queue, ^{ sleep(2); NSLog(@"barrier"); });

dispatch_async(concurrent_queue, ^{ sleep(2); NSLog(@"finish1"); });
dispatch_async(concurrent_queue, ^{ NSLog(@"finish2"); });

這也是「多讀單寫」模型的經典實現方式:讀操作自由並發,寫操作通過柵欄獨佔。

重複執行與單次執行

dispatch_apply() 把一個任務提交到隊列中重複執行,串行還是並行取決於隊列類型。它會阻塞當前線程,直到所有任務完成後才返回:

dispatch_queue_t concurrent_queue = dispatch_queue_create("concurrent.queue", DISPATCH_QUEUE_CONCURRENT);

dispatch_apply(5, concurrent_queue, ^(size_t index) {
    sleep(1);
    NSLog(@"index:%zu", index);
});
NSLog(@"finish");

dispatch_once() 確保 block 內的代碼在整個應用生命週期內只執行一次,單例實現的標準寫法:

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    NSLog(@"just run once in application");
});

線程同步、信號量與死鎖

多線程場景下,資源爭搶幾乎無法迴避——經典的售票問題、資料庫並發寫入都屬於這一類。解決思路很多,最簡單的兩種是加同步鎖和用信號量。

同步鎖:線程訪問鎖內資源時會先上鎖,拒絕其他線程進入,直到佔用的線程退出後才解鎖。

@synchronized(self) {
    NSLog(@"lock");
};

信號量 dispatch_semaphore:先設定信號總量,再用 dispatch_semaphore_wait() 和 dispatch_semaphore_signal() 管理,以此控制並發規模:

dispatch_group_t group = dispatch_group_create();
// 設置總信號量為 10
dispatch_semaphore_t semaphore = dispatch_semaphore_create(10);

for (int i = 0; i < 100; i++) {
    // 等待信號:此時信號量大於 0 則減一並繼續往下執行;
    // 小於 0 則一直等待直到超時。超時返回非零,成功返回 0
    dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 50));

    dispatch_group_async(group, concurrent_queue, ^{
        sleep(1);
        NSLog(@"%d", i);
        // 發送信號,讓信號量加一
        dispatch_semaphore_signal(semaphore);
    });
}

dispatch_group_notify(group, concurrent_queue, ^{ NSLog(@"finish"); });

三種典型的死鎖場景

GCD 寫起來輕鬆,但用得不當也會製造麻煩。下面三種情況都值得警惕:

// 場景一:並行隊列中對當前隊列 dispatch_sync —— 不會死鎖
// dispatch_sync 會阻塞當前線程,但隊列是並行執行,
// block 中的任務能立即被另一條線程接手並返回
- (void)syncAndConcurrentQueue {
    dispatch_queue_t queue = dispatch_queue_create("concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{
        NSLog(@"Jump to concurrent.queue! ,thread:%@",[NSThread currentThread]);
        dispatch_sync(queue, ^{
            sleep(3);
            NSLog(@"success ,thread:%@",[NSThread currentThread]);
        });
        NSLog(@"return");
    });
}

// 場景二:串行隊列中對當前隊列 dispatch_sync —— 必然死鎖
// dispatch_sync 阻塞當前線程等待 block 完成,
// 但串行隊列要求先完成正在執行的任務(也就是外層 dispatch_sync 自己),
// 而 block 排在隊尾永遠沒有機會執行
- (void)syncAndSerialQueue {
    dispatch_queue_t queue = dispatch_queue_create("serial.queue", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{
        NSLog(@"Jump to serial.queue!");
        dispatch_sync(queue, ^{
            NSLog(@"success");
        });
        NSLog(@"return");
    });
}

// 場景三:交錯同步等待造成雙向死鎖
- (void)recycle {
    dispatch_queue_t concurrent_queue = dispatch_queue_create("concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
    // 任務 1
    dispatch_sync(concurrent_queue, ^{
        NSLog(@"jump to concurrent queue");
        // 任務 2:在主線程上再提交一個同步任務
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"return main queue");
        });
    });
}

場景三的原理是:任務 1 阻塞主線程直到 block 返回,而任務 2 試圖在主線程上同步等待,兩條線程互相等待對方釋放,於是死鎖。判斷死鎖有個簡單的口訣——不要在當前正在執行的隊列上對自己 dispatch_sync,尤其要小心主隊列。

總結

GCD 的優勢在於輕量、貼近系統;短板在於處理取消任務、任務間依賴這類場景時比較笨拙。因此經驗法則是:功能簡單時優先用 GCD;一旦邏輯變複雜,改用 NSOperation 和 NSOperationQueue 會舒服很多——它們底層依然由 GCD 實現,但完全面向對象,取消、依賴、優先級都好表達,可讀性也更強。

示例代碼地址:https://github.com/GarenChen/GCDDemo

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved