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