您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

GCD 實戰經驗與踩坑筆記:那些容易出事的 API 行為

編輯:iOS 開發基礎

前言

GCD(Grand Central Dispatch)堪稱 Mac 與 iOS 開發的一大利器。本文不做 API 手冊式羅列,而是總結實戰中容易踩到的坑與對應的正確用法。

dispatch_once_t 必須是全局或 static 變量

這條算老生常談,但仍值得反覆強調:非全局、非 static 的 dispatch_once_t 會引發極難排查的 bug。正確寫法:

// 靜態變量保證全局只有一份,才能確保只執行一次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    // 單例初始化代碼
});

本質上就是保證 dispatch_once_t 只有唯一一份實例。

dispatch_queue_create 的第二個參數

創建隊列的函數原型是:

dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);

多數教程(甚至 Apple 自己的文檔)都這樣寫:

dispatch_queue_t queue = dispatch_queue_create("com.example.MyQueue", NULL);

但 dispatch_queue_attr_t 是有現成常量的。為了讓代碼語義更清晰、更嚴謹,建議直接寫明:

// 串行隊列
dispatch_queue_t queue = dispatch_queue_create("com.example.MyQueue", DISPATCH_QUEUE_SERIAL);

// 並行隊列
dispatch_queue_t queue = dispatch_queue_create("com.example.MyQueue", DISPATCH_QUEUE_CONCURRENT);

常量存在的意義就是讓代碼自證其意,既然有,何必不用。

dispatch_after 是「延遲提交」,不是「延遲執行」

先看官方文檔的措辭:

Enqueue a block for execution at the specified time.

關鍵詞是 Enqueue(入隊):它指的是在指定延時之後把 block 加入隊列,而不是到點立刻執行。示例:

// 創建並行隊列
dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_CONCURRENT);

NSLog(@"Begin add block...");

// 提交一個 block,內部 sleep 10 秒
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:10];
    NSLog(@"First block done...");
});

// 5 秒後「提交」block
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), queue, ^{
    NSLog(@"After...");
});

實際輸出:

2015-03-31 20:57:27.122 GCDTest[45633:1812016] Begin add block...
2015-03-31 20:57:37.127 GCDTest[45633:1812041] First block done...
2015-03-31 20:57:37.127 GCDTest[45633:1812041] After...

結果驗證了前面的判斷:延時 5 秒後 block 才被提交,此時隊列仍被前一個任務佔用,於記立即執行。所以想靠 dispatch_after 精確控制執行時序的朋友要格外小心。

正確構造 dispatch_time_t

函數原型:

dispatch_time_t dispatch_time(dispatch_time_t when, int64_t delta);

第一個參數一般傳 DISPATCH_TIME_NOW,表示從現在起算;第二個參數才是真正的延時量。

要特別注意:delta 的單位是納秒。延時 1 秒就得寫 1000000000,實在反人類,因此系統提供了常量:

#define NSEC_PER_SEC 1000000000ull
#define USEC_PER_SEC 1000000ull
#define NSEC_PER_USEC 1000ull

命名規則很規整:NSEC 是納秒,USEC 是微秒,SEC 是秒,PER 是「每」。於是:

  • NSEC_PER_SEC:一秒有多少納秒
  • USEC_PER_SEC:一秒有多少微秒
  • NSEC_PER_USEC:一微秒有多少納秒

所以延時 1 秒可以寫成幾種等價形式:

dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC);
dispatch_time(DISPATCH_TIME_NOW, 1000 * USEC_PER_SEC);
dispatch_time(DISPATCH_TIME_NOW, USEC_PER_SEC * NSEC_PER_USEC);

最後一種翻譯過來是「每秒的微秒數 × 每微秒的納秒數」,也就是「每秒的納秒數」。理解到這一步,延時 500 毫秒之類的換算自然不在話下。

dispatch_suspend 不等於立即停止隊列

dispatch_suspend 與 dispatch_resume 提供了隊列級別的掛起與恢復能力,但這裡的「掛起」並不能保證 立即 中止正在執行的 block:

dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);

// 第一個 block:5 秒後打印
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:5];
    NSLog(@"After 5 seconds...");
});

// 第二個 block:同樣 5 秒後打印
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:5];
    NSLog(@"After 5 seconds again...");
});

// 主線程等 1 秒後掛起隊列
NSLog(@"sleep 1 second...");
[NSThread sleepForTimeInterval:1];

NSLog(@"suspend...");
dispatch_suspend(queue);

// 掛起狀態下等 10 秒
NSLog(@"sleep 10 second...");
[NSThread sleepForTimeInterval:10];

NSLog(@"resume...");
dispatch_resume(queue);

輸出:

2015-04-01 00:32:09.903 GCDTest[47201:1883834] sleep 1 second...
2015-04-01 00:32:10.910 GCDTest[47201:1883834] suspend...
2015-04-01 00:32:10.910 GCDTest[47201:1883834] sleep 10 second...
2015-04-01 00:32:14.908 GCDTest[47201:1883856] After 5 seconds...
2015-04-01 00:32:20.911 GCDTest[47201:1883834] resume...
2015-04-01 00:32:25.912 GCDTest[47201:1883856] After 5 seconds again...

可見掛起之後第一個 block 仍在正常執行並輸出。結合文檔可知:dispatch_suspend 不會中止正在跑的任務,而是等當前 block 執行完畢後,暫停後續 block 的調度。因此,若你的目標是「立刻停下正在執行的任務」,它並不是合適的工具。

「同步」的 dispatch_apply

dispatch_apply 用來在指定隊列上重複執行同一個 block 若干次,相當於語法糖版的循環提交。但它有個容易忽略的特性:

dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);

dispatch_apply(3, queue, ^(size_t i) {
    NSLog(@"apply loop: %zu", i);
});

NSLog(@"After apply");

輸出:

2015-04-01 00:55:40.854 GCDTest[47402:1893289] apply loop: 0
2015-04-01 00:55:40.856 GCDTest[47402:1893289] apply loop: 1
2015-04-01 00:55:40.856 GCDTest[47402:1893289] apply loop: 2
2015-04-01 00:55:40.856 GCDTest[47402:1893289] After apply

注意:隊列是異步的,但「After apply」仍然排在循環之後輸出——說明 dispatch_apply 會阻塞調用它的線程,直到所有循環執行完才返回。查官方文檔也是同樣說法。主線程上用它,慎之。

警惕死鎖

dispatch_sync 導致的死鎖

多線程編程裡死鎖是繞不開的話題,而 GCD 中一些組合會毫不客氣地讓 App 卡死:

// 在主線程用同步方式往主隊列提交,必死
dispatch_sync(dispatch_get_main_queue(), ^{
    NSLog(@"I am block...");
});

有人會說這種低級錯誤不會犯。那看看稍微隱蔽一點的版本:

- (void)updateUI1 {
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"Update ui 1");

        // 死鎖!
        [self updateUI2];
    });
}

- (void)updateUI2 {
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"Update ui 2");
    });
}

嵌套調用在不經意間就造成了死鎖。為了「世界和平」,能不用 dispatch_sync 就別用。

dispatch_apply 導致的死鎖

既然 dispatch_apply 會等待循環結束,它本質上就帶有阻塞語義,嵌套使用自然出事:

dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);

dispatch_apply(3, queue, ^(size_t i) {
    NSLog(@"apply loop: %zu", i);

    // 再套一層 dispatch_apply —— 死鎖
    dispatch_apply(3, queue, ^(size_t j) {
        NSLog(@"apply loop inside %zu", j);
    });
});

這段代碼只會輸出「apply loop: 1」,然後就再也沒有然後了。請務必避免 dispatch_apply 的嵌套調用。

靈活使用 dispatch_group

我們經常需要「等一批任務全部完成,再做收尾」。如果任務本身有序、可拆成步驟,串行隊列就够了;但如果這批任務是並行執行的,就需要 dispatch_group。使用步驟是:

  1. 創建 dispatch_group_t
  2. 把任務加入 group
  3. 掛上結束後的收尾任務(清理、通知 UI 等)

添加任務

分兩種情況。若隊列變量在自己手裡,直接用 dispatch_group_async:

// 省略 group、queue 的創建代碼
dispatch_group_async(group, queue, ^{
    // Do your work...
});

若拿不到隊列變量(例如通過 AFNetworking 發請求),改用 dispatch_group_enter 與 dispatch_group_leave:

AFHTTPRequestOperationManager *manager = [AFHTTPRequestOperationManager manager];

// 進入 group
dispatch_group_enter(group);

[manager GET:@"https://www.baidu.com" parameters:nil
     success:^(AFHTTPRequestOperation *operation, id responseObject) {
         // 處理結果
         // 離開 group
         dispatch_group_leave(group);
     }
     failure:^(AFHTTPRequestOperation *operation, NSError *error) {
         // 處理錯誤
         // 離開 group
         dispatch_group_leave(group);
     }];

// 更多請求……

這對 enter/leave 可以把一堆異步網絡請求「打包」成一個整體。要留意:每個 enter 都必須有配對的 leave,且成功與失敗分支都要兼顧,否則收尾任務永遠等不到。

添加收尾任務

同樣兩種選擇:

  1. 在當前線程阻塞等待:dispatch_group_wait
  2. 異步執行收尾任務:dispatch_group_notify

dispatch_barrier_async / dispatch_barrier_sync 的注意事項

barrier 的作用是往隊列中插入一個「屏障」block:等前面已入隊的任務跑完後,它會獨佔執行,其後追加的 block 必須等它結束才能繼續,頗有一點「唯我獨尊」的味道。

需要牢記:barrier 系列函數只在你自己創建的並發隊列上有效。在全局並發隊列和串行隊列上,它的行為與普通的 dispatch_(a)sync 完全相同。既然在串行隊列上等價於 dispatch_sync,那就要格外小心死鎖。

dispatch_set_context 與 dispatch_set_finalizer_f 的配合

dispatch_set_context 可以為隊列關聯上下文數據,但 GCD 是 C 接口,context 的類型是 void *。因此你有幾種選擇:

  • 用 C 的 malloc 分配內存
  • 用 C++ 的 new 創建對象
  • 用 Objective-C 對象,但需要通過 __bridge 等關鍵字轉為 Core Foundation 對象

三種方式有個共同要求:必須釋放。無論用 free、delete 還是 CFRelease,都要確保隊列不再使用時及時回收,否則就是內存洩露。

因此使用 dispatch_set_context 時,最好搭配 dispatch_set_finalizer_f 給隊列掛一個「析構函數」,在其中完成釋放:

void cleanStaff(void *context) {
    // 在此釋放 context 的內存
    // CFRelease(context);
    // free(context);
    // delete context;
}

// 隊列創建後,設置其「析構函數」
dispatch_set_finalizer_f(queue, cleanStaff);

總結

寫到這裡發現,本文更像是一份 GCD 的「坑位清單」。而真正的經驗只有一條:任何技術都要研究透徹再用,否則後患無窮。

參考資料

  • Grand Central Dispatch (GCD) Reference
  • Concurrency Programming Guide
  • Using Dispatch Groups to Wait for Multiple Web Services
  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved