當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

iOS进阶 - GCD总结

發(fā)布時間：2023/12/16 编程问答 54 豆豆

生活随笔收集整理的這篇文章主要介紹了 iOS进阶 - GCD总结小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.

前言

Grand Central Dispatch（GCD） 是 Apple 開發(fā)的一個多核編程的較新的解決方法。它主要用于優(yōu)化應用程序以支持多核處理器以及其他對稱多處理系統(tǒng)。它是一個在線程池模式的基礎(chǔ)上執(zhí)行的并發(fā)任務。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。

使用 GCD 的好處：

GCD 可用于多核的并行運算；
GCD 會自動利用更多的 CPU 內(nèi)核（比如雙核、四核）；
GCD 會自動管理線程的生命周期（創(chuàng)建線程、調(diào)度任務、銷毀線程）；
程序員只需要告訴 GCD 想要執(zhí)行什么任務，不需要編寫任何線程管理代碼。

1. GCD 任務和隊列

任務：就是執(zhí)行操作的意思，換句話說就是你在線程中執(zhí)行的那段代碼。在 GCD 中是放在 block 中的。執(zhí)行任務有兩種方式：同步執(zhí)行?和 異步執(zhí)行。兩者的主要區(qū)別是：是否等待隊列的任務執(zhí)行結(jié)束，以及是否具備開啟新線程的能力。

同步執(zhí)行（sync）：
- 同步添加任務到指定的隊列中，在添加的任務執(zhí)行結(jié)束之前，會一直等待，直到隊列里面的任務完成之后再繼續(xù)執(zhí)行。
- 只能在當前線程中執(zhí)行任務，不具備開啟新線程的能力。
異步執(zhí)行（async）：
- 異步添加任務到指定的隊列中，它不會做任何等待，可以繼續(xù)執(zhí)行任務。
- 可以在新的線程中執(zhí)行任務，具備開啟新線程的能力。

注意：異步執(zhí)行（async）雖然具有開啟新線程的能力，但是并不一定開啟新線程。這跟任務所指定的隊列類型有關(guān)（下面會講）。

隊列（Dispatch Queue）：這里的隊列指執(zhí)行任務的等待隊列，即用來存放任務的隊列。隊列是一種特殊的線性表，采用 FIFO（先進先出）的原則，即新任務總是被插入到隊列的末尾，而讀取任務的時候總是從隊列的頭部開始讀取。每讀取一個任務，則從隊列中釋放一個任務。隊列的結(jié)構(gòu)可參考下圖：

在 GCD 中有兩種隊列：『串行隊列』?和?『并發(fā)隊列』。兩者都符合 FIFO（先進先出）的原則。兩者的主要區(qū)別是：執(zhí)行順序不同，以及開啟線程數(shù)不同。

串行隊列（Serial Dispatch Queue）：
- 每次只有一個任務被執(zhí)行。讓任務一個接著一個地執(zhí)行。（只開啟一個線程，一個任務執(zhí)行完畢后，再執(zhí)行下一個任務）
并發(fā)隊列（Concurrent Dispatch Queue）：
- 可以讓多個任務并發(fā)（同時）執(zhí)行。（可以開啟多個線程，并且同時執(zhí)行任務）

注意：并發(fā)隊列 的并發(fā)功能只有在異步（dispatch_async）方法下才有效。

2. GCD 的使用步驟

創(chuàng)建一個隊列（串行隊列或并發(fā)隊列）；

將任務追加到任務的等待隊列中，然后系統(tǒng)就會根據(jù)任務類型執(zhí)行任務（同步執(zhí)行或異步執(zhí)行）。

2.1 隊列的創(chuàng)建方法 / 獲取方法

可以使用 dispatch_queue_create 方法來創(chuàng)建隊列。該方法需要傳入兩個參數(shù)：

第一個參數(shù)表示隊列的唯一標識符，用于 DEBUG，可為空。隊列的名稱推薦使用應用程序 ID 這種逆序全程域名。
第二個參數(shù)用來識別是串行隊列還是并發(fā)隊列。DISPATCH_QUEUE_SERIAL 表示串行隊列，DISPATCH_QUEUE_CONCURRENT 表示并發(fā)隊列。

// 串行隊列的創(chuàng)建方法 dispatch_queue_t queue = dispatch_queue_create("com.hiccup.myQueue", DISPATCH_QUEUE_SERIAL); // 并發(fā)隊列的創(chuàng)建方法 dispatch_queue_t queue = dispatch_queue_create("com.hiccup.myQueue", DISPATCH_QUEUE_CONCURRENT);

對于串行隊列，GCD 默認提供了：主隊列（Main Dispatch Queue）。

所有放在主隊列中的任務，都會放到主線程中執(zhí)行。
可使用 dispatch_get_main_queue() 方法獲得主隊列。

注意：主隊列其實并不特殊。?主隊列的實質(zhì)上就是一個普通的串行隊列，只是因為默認情況下，當前代碼是放在主隊列中的，然后主隊列中的代碼，有都會放到主線程中去執(zhí)行，所以才造成了主隊列特殊的現(xiàn)象。

// 主隊列的獲取方法 dispatch_queue_t queue = dispatch_get_main_queue();

對于并發(fā)隊列，GCD 默認提供了 『全局并發(fā)隊列（Global Dispatch Queue）』。

可以使用 dispatch_get_global_queue 方法來獲取全局并發(fā)隊列。需要傳入兩個參數(shù)。第一個參數(shù)表示隊列優(yōu)先級，一般用 DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數(shù)暫時沒用，用 0 即可。

// 全局并發(fā)隊列的獲取方法 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

2.2 任務的創(chuàng)建方法

GCD 提供了同步執(zhí)行任務的創(chuàng)建方法?dispatch_sync?和異步執(zhí)行任務創(chuàng)建方法?dispatch_async。

// 同步執(zhí)行任務創(chuàng)建方法 dispatch_sync(queue, ^{// 這里放同步執(zhí)行任務代碼 }); // 異步執(zhí)行任務創(chuàng)建方法 dispatch_async(queue, ^{// 這里放異步執(zhí)行任務代碼 });

雖然使用 GCD 只需兩步，但是既然我們有兩種隊列（串行隊列 / 并發(fā)隊列），兩種任務執(zhí)行方式（同步執(zhí)行 / 異步執(zhí)行），那么我們就有了四種不同的組合方式。這四種不同的組合方式是：

同步執(zhí)行 + 并發(fā)隊列

異步執(zhí)行 + 并發(fā)隊列

同步執(zhí)行 + 串行隊列

異步執(zhí)行 + 串行隊列

實際上，剛才還說了兩種默認隊列：全局并發(fā)隊列、主隊列。全局并發(fā)隊列可以作為普通并發(fā)隊列來使用。但是當前代碼默認放在主隊列中，所以主隊列很有必要專門來研究一下，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。

? ? 5、同步執(zhí)行 + 主隊列

? ? 6、異步執(zhí)行 + 主隊列

2.3 任務和隊列不同組合方式的區(qū)別

主線程?中，不同隊列?+?不同任務?簡單組合的區(qū)別：

區(qū)別并發(fā)隊列串行隊列主隊列

同步（sync）	沒有開啟新線程，串行執(zhí)行任務	沒有開啟新線程，串行執(zhí)行任務	死鎖卡住不執(zhí)行
異步（async）	有開啟新線程，并發(fā)執(zhí)行任務	有開啟新線程（1條），串行執(zhí)行任務	沒有開啟新線程，串行執(zhí)行任務

注意：從上邊可看出： 主線程?中調(diào)用 主隊列 + 同步執(zhí)行?會導致死鎖問題。
這是因為 主隊列中追加的同步任務 和 主線程本身的任務 兩者之間相互等待，阻塞了 主隊列，最終造成了主隊列所在的線程（主線程）死鎖問題。

2.4 隊列嵌套情況下，不同組合方式區(qū)別

不同隊列 + 不同任務?組合，以及 隊列中嵌套隊列?使用的區(qū)別：

區(qū)別【異步執(zhí)行+并發(fā)隊列】嵌套【同一個并發(fā)隊列】『同步執(zhí)行+并發(fā)隊列』嵌套『同一個并發(fā)隊列』『異步執(zhí)行+串行隊列』嵌套『同一個串行隊列』『同步執(zhí)行+串行隊列』嵌套『同一個串行隊列』

同步（sync）	沒有開啟新的線程，串行執(zhí)行任務	沒有開啟新線程，串行執(zhí)行任務	死鎖卡住不執(zhí)行	死鎖卡住不執(zhí)行
異步（async）	有開啟新線程，并發(fā)執(zhí)行任務	有開啟新線程，并發(fā)執(zhí)行任務	有開啟新線程（1 條），串行執(zhí)行任務	有開啟新線程（1 條），串行執(zhí)行任務

3. GCD 的基本使用

3.1 同步執(zhí)行 + 并發(fā)隊列

在當前線程中執(zhí)行任務，不會開啟新線程，執(zhí)行完一個任務，再執(zhí)行下一個任務。

/*** 同步執(zhí)行 + 并發(fā)隊列* 特點：在當前線程中執(zhí)行任務，不會開啟新線程，執(zhí)行完一個任務，再執(zhí)行下一個任務。*/ - (void)syncConcurrent {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"syncConcurrent---begin");dispatch_queue_t queue = dispatch_queue_create("com.hiccup.myQueue", DISPATCH_QUEUE_CONCURRENT);dispatch_sync(queue, ^{// 追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程});dispatch_sync(queue, ^{// 追加任務 2[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程});dispatch_sync(queue, ^{// 追加任務 3[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程});NSLog(@"syncConcurrent---end"); }

輸出結(jié)果：
?currentThread---<NSThread: 0x600006748362>{number = 1, name = main}
?syncConcurrent---begin
?1---<NSThread: 0x600006748362>{number = 1, name = main}
?2---<NSThread: 0x600006748362>{number = 1, name = main}
?3---<NSThread: 0x600006748362>{number = 1, name = main}
?syncConcurrent---end

從同步執(zhí)行 + 并發(fā)隊列中可看到：

所有任務都是在當前線程（主線程）中執(zhí)行的，沒有開啟新的線程（同步執(zhí)行不具備開啟新線程的能力）。
所有任務都在打印的 syncConcurrent---begin 和 syncConcurrent---end 之間執(zhí)行的（同步任務需要等待隊列的任務執(zhí)行結(jié)束）。
任務按順序執(zhí)行的。按順序執(zhí)行的原因：雖然并發(fā)隊列可以開啟多個線程，并且同時執(zhí)行多個任務。但是因為本身不能創(chuàng)建新線程，只有當前線程這一個線程（同步任務不具備開啟新線程的能力），所以也就不存在并發(fā)。而且當前線程只有等待當前隊列中正在執(zhí)行的任務執(zhí)行完畢之后，才能繼續(xù)接著執(zhí)行下面的操作（同步任務需要等待隊列的任務執(zhí)行結(jié)束）。所以任務只能一個接一個按順序執(zhí)行，不能同時被執(zhí)行。

3.2 異步執(zhí)行 + 并發(fā)隊列

可以開啟多個線程，任務交替（同時）執(zhí)行。

/*** 異步執(zhí)行 + 并發(fā)隊列* 特點：可以開啟多個線程，任務交替（同時）執(zhí)行。*/ - (void)asyncConcurrent {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"asyncConcurrent---begin");dispatch_queue_t queue = dispatch_queue_create("com.hiccup.myQueue", DISPATCH_QUEUE_CONCURRENT);dispatch_async(queue, ^{// 追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程});dispatch_async(queue, ^{// 追加任務 2[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程});dispatch_async(queue, ^{// 追加任務 3[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程});NSLog(@"asyncConcurrent---end"); }

輸出結(jié)果：
?currentThread---<NSThread: 0x60000706d670>{number = 1, name = main}
?asyncConcurrent---begin
?asyncConcurrent---end
?2---<NSThread: 0x600007364720>{number = 4, name = (null)}
?3---<NSThread: 0x600007371450>{number = 6, name = (null)}
?1---<NSThread: 0x600007354560>{number = 5, name = (null)}

在異步執(zhí)行 + 并發(fā)隊列中可以看出：

除了當前線程（主線程），系統(tǒng)又開啟了 3 個線程，并且任務是交替/同時執(zhí)行的。（異步執(zhí)行具備開啟新線程的能力。且并發(fā)隊列可開啟多個線程，同時執(zhí)行多個任務）。
所有任務是在打印的 syncConcurrent---begin 和 syncConcurrent---end 之后才執(zhí)行的。說明當前線程沒有等待，而是直接開啟了新線程，在新線程中執(zhí)行任務（異步執(zhí)行不做等待，可以繼續(xù)執(zhí)行任務）。

3.3 同步執(zhí)行 + 串行隊列

不會開啟新線程，在當前線程執(zhí)行任務。任務是串行的，執(zhí)行完一個任務，再執(zhí)行下一個任務。

/*** 同步執(zhí)行 + 串行隊列* 特點：不會開啟新線程，在當前線程執(zhí)行任務。任務是串行的，執(zhí)行完一個任務，再執(zhí)行下一個任務。*/ - (void)syncSerial {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"syncSerial---begin");dispatch_queue_t queue = dispatch_queue_create("com.hiccup.myQueue", DISPATCH_QUEUE_SERIAL);dispatch_sync(queue, ^{// 追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程});dispatch_sync(queue, ^{// 追加任務 2[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程});dispatch_sync(queue, ^{// 追加任務 3[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程});NSLog(@"syncSerial---end"); }

輸出結(jié)果為：
?currentThread---<NSThread: 0x600003c6e530>{number = 1, name = main}
?syncSerial---begin
?1---<NSThread: 0x600003c6e530>{number = 1, name = main}
?2---<NSThread: 0x600003c6e530>{number = 1, name = main}
?3---<NSThread: 0x600003c6e530>{number = 1, name = main}
?syncSerial---end

在同步執(zhí)行 + 串行隊列可以看到：

所有任務都是在當前線程（主線程）中執(zhí)行的，并沒有開啟新的線程（同步執(zhí)行不具備開啟新線程的能力）。
所有任務都在打印的 syncConcurrent---begin 和 syncConcurrent---end 之間執(zhí)行（同步任務需要等待隊列的任務執(zhí)行結(jié)束）。
任務是按順序執(zhí)行的（串行隊列每次只有一個任務被執(zhí)行，任務一個接一個按順序執(zhí)行）。

3.4 異步執(zhí)行 + 串行隊列

會開啟新線程，但是因為任務是串行的，執(zhí)行完一個任務，再執(zhí)行下一個任務

/*** 異步執(zhí)行 + 串行隊列* 特點：會開啟新線程，但是因為任務是串行的，執(zhí)行完一個任務，再執(zhí)行下一個任務。*/ - (void)asyncSerial {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"asyncSerial---begin");dispatch_queue_t queue = dispatch_queue_create("com.hiccup.myQueue", DISPATCH_QUEUE_SERIAL);dispatch_async(queue, ^{// 追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程});dispatch_async(queue, ^{// 追加任務 2[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程});dispatch_async(queue, ^{// 追加任務 3[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程});NSLog(@"asyncSerial---end"); }

輸出結(jié)果為：
?currentThread---<NSThread: 0x6000042e2570>{number = 1, name = main}
?asyncSerial---begin
?asyncSerial---end
?1---<NSThread: 0x6000043c2310>{number = 3, name = (null)}
?2---<NSThread: 0x6000043c2310>{number = 3, name = (null)}
?3---<NSThread: 0x6000043c2310>{number = 3, name = (null)}

在異步執(zhí)行 + 串行隊列可以看到：

開啟了一條新線程（異步執(zhí)行具備開啟新線程的能力，串行隊列只開啟一個線程）。
所有任務是在打印的 syncConcurrent---begin 和 syncConcurrent---end 之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務）。
任務是按順序執(zhí)行的（串行隊列每次只有一個任務被執(zhí)行，任務一個接一個按順序執(zhí)行）。

3.5 同步執(zhí)行 + 主隊列

同步執(zhí)行 + 主隊列?在不同線程中調(diào)用結(jié)果也是不一樣，在主線程中調(diào)用會發(fā)生死鎖問題，而在其他線程中調(diào)用則不會。

3.5.1 在主線程中調(diào)用『同步執(zhí)行 + 主隊列』

互相等待卡住不可行

/*** 同步執(zhí)行 + 主隊列* 特點(主線程調(diào)用)：互等卡主不執(zhí)行。* 特點(其他線程調(diào)用)：不會開啟新線程，執(zhí)行完一個任務，再執(zhí)行下一個任務。*/ - (void)syncMain {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"syncMain---begin");dispatch_queue_t queue = dispatch_get_main_queue();dispatch_sync(queue, ^{// 追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程});dispatch_sync(queue, ^{// 追加任務 2[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程});dispatch_sync(queue, ^{// 追加任務 3[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程});NSLog(@"syncMain---end"); }

輸出結(jié)果（Xcode 9 以下版本）
?currentThread---<NSThread: 0x6000042c5570>{number = 1, name = main}
?syncMain---begin
(lldb)

在主線程中使用同步執(zhí)行 + 主隊列可以驚奇的發(fā)現(xiàn)：

追加到主線程的任務 1、任務 2、任務 3 都不再執(zhí)行了，而且 syncMain---end 也沒有打印，在 XCode 9 及以上版本上還會直接報崩潰。這是為什么呢？【Thread 1: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0)】

這是因為我們在主線程中執(zhí)行 syncMain 方法，相當于把 syncMain 任務放到了主線程的隊列中。而同步執(zhí)行會等待當前隊列中的任務執(zhí)行完畢，才會接著執(zhí)行。那么當我們把任務 1 追加到主隊列中，任務 1 就在等待主線程處理完 syncMain 任務。而syncMain 任務需要等待任務 1 執(zhí)行完畢，才能接著執(zhí)行。

3.5.2 在其他線程中調(diào)用『同步執(zhí)行 + 主隊列』

不會開啟新線程，執(zhí)行完一個任務，再執(zhí)行下一個任務

// 使用 NSThread 的 detachNewThreadSelector 方法會創(chuàng)建線程，并自動啟動線程執(zhí)行 selector 任務 [NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];

輸出結(jié)果：
?currentThread---<NSThread: 0x600003ad2a20>{number = 3, name = (null)}
?syncMain---begin
?1---<NSThread: 0x60000382a340>{number = 1, name = main}
?2---<NSThread: 0x60000382a340>{number = 1, name = main}
?3---<NSThread: 0x60000382a340>{number = 1, name = main}
?syncMain---end

在其他線程中使用同步執(zhí)行 + 主隊列可看到：

所有任務都是在主線程（非當前線程）中執(zhí)行的，沒有開啟新的線程（所有放在主隊列中的任務，都會放到主線程中執(zhí)行）。
所有任務都在打印的 syncConcurrent---begin 和 syncConcurrent---end 之間執(zhí)行（同步任務需要等待隊列的任務執(zhí)行結(jié)束）。
任務是按順序執(zhí)行的（主隊列是串行隊列，每次只有一個任務被執(zhí)行，任務一個接一個按順序執(zhí)行）。

為什么現(xiàn)在就不會卡住了呢？

因為syncMain 任務放到了其他線程里，而任務 1、任務 2、任務3 都在追加到主隊列中，這三個任務都會在主線程中執(zhí)行。syncMain 任務在其他線程中執(zhí)行到追加任務 1 到主隊列中，因為主隊列現(xiàn)在沒有正在執(zhí)行的任務，所以，會直接執(zhí)行主隊列的任務1，等任務1 執(zhí)行完畢，再接著執(zhí)行任務 2、任務 3。所以這里不會卡住線程，也就不會造成死鎖問題。

3.6 異步執(zhí)行 + 主隊列

只在主線程中執(zhí)行任務，執(zhí)行完一個任務，再執(zhí)行下一個任務。

/*** 異步執(zhí)行 + 主隊列* 特點：只在主線程中執(zhí)行任務，執(zhí)行完一個任務，再執(zhí)行下一個任務*/ - (void)asyncMain {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"asyncMain---begin");dispatch_queue_t queue = dispatch_get_main_queue();dispatch_async(queue, ^{// 追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程});dispatch_async(queue, ^{// 追加任務 2[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程});dispatch_async(queue, ^{// 追加任務 3[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程});NSLog(@"asyncMain---end"); }

輸出結(jié)果：
?currentThread---<NSThread: 0x6000032e2160>{number = 1, name = main}
?asyncMain---begin
?asyncMain---end
?1---<NSThread: 0x6000032e2160>{number = 1, name = main}
?2---<NSThread: 0x6000032e2160>{number = 1, name = main}
?3---<NSThread: 0x6000032e2160>{number = 1, name = main}

在異步執(zhí)行 + 主隊列可以看到：

所有任務都是在當前線程（主線程）中執(zhí)行的，并沒有開啟新的線程（雖然異步執(zhí)行具備開啟線程的能力，但因為是主隊列，所以所有任務都在主線程中）。
所有任務是在打印的 syncConcurrent---begin 和 syncConcurrent---end 之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務）。
任務是按順序執(zhí)行的（因為主隊列是串行隊列，每次只有一個任務被執(zhí)行，任務一個接一個按順序執(zhí)行）。

4. GCD 線程間的通信

在 iOS 開發(fā)過程中，我們一般在主線程里邊進行 UI 刷新，例如：點擊、滾動、拖拽等事件。我們通常把一些耗時的操作放在其他線程，比如說圖片下載、文件上傳等耗時操作。而當我們有時候在其他線程完成了耗時操作時，需要回到主線程，那么就用到了線程之間的通訊。

/*** 線程間通信*/ - (void)communication {// 獲取全局并發(fā)隊列dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);// 獲取主隊列dispatch_queue_t mainQueue = dispatch_get_main_queue();dispatch_async(queue, ^{// 異步追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程// 回到主線程dispatch_async(mainQueue, ^{// 追加在主線程中執(zhí)行的任務[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程});}); }

輸出結(jié)果：
?1---<NSThread: 0x60000432a580>{number = 3, name = (null)}
?2---<NSThread: 0x60000431e320>{number = 1, name = main}

可以看到在其他線程中先執(zhí)行任務，執(zhí)行完了之后回到主線程執(zhí)行主線程的相應操作。

5. GCD 的其他方法

5.1 GCD 柵欄方法：dispatch_barrier_async

我們有時需要異步執(zhí)行兩組操作，而且第一組操作執(zhí)行完之后，才能開始執(zhí)行第二組操作。這樣我們就需要一個相當于柵欄一樣的一個方法將兩組異步執(zhí)行的操作組給分割起來，當然這里的操作組里可以包含一個或多個任務。這就需要用到dispatch_barrier_async 方法在兩個操作組間形成柵欄。
dispatch_barrier_async 方法會等待前邊追加到并發(fā)隊列中的任務全部執(zhí)行完畢之后，再將指定的任務追加到該異步隊列中。然后在 dispatch_barrier_async 方法追加的任務執(zhí)行完畢之后，異步隊列才恢復為一般動作，接著追加任務到該異步隊列并開始執(zhí)行。具體如下圖所示：

/*** 柵欄方法 dispatch_barrier_async*/ - (void)barrier {dispatch_queue_t queue = dispatch_queue_create("com.hiccup.myQueue", DISPATCH_QUEUE_CONCURRENT);dispatch_async(queue, ^{// 追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程});dispatch_async(queue, ^{// 追加任務 2[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程});dispatch_barrier_async(queue, ^{// 追加任務 barrier[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"barrier---%@",[NSThread currentThread]);// 打印當前線程});dispatch_async(queue, ^{// 追加任務 3[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程});dispatch_async(queue, ^{// 追加任務 4[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"4---%@",[NSThread currentThread]); // 打印當前線程}); }

輸出結(jié)果：
?1---<NSThread: 0x6000057a3210>{number = 3, name = (null)}
?2---<NSThread: 0x600005a23440>{number = 4, name = (null)}
?barrier---<NSThread: 0x6000057a3210>{number = 3, name = (null)}
?4---<NSThread: 0x600005a23440>{number = 4, name = (null)}
?3---<NSThread: 0x6000057a3210>{number = 3, name = (null)}

在?dispatch_barrier_async?執(zhí)行結(jié)果中可以看出：

在執(zhí)行完柵欄前面的操作之后，才執(zhí)行柵欄操作，最后再執(zhí)行柵欄后邊的操作。

5.2 GCD 延時執(zhí)行方法：dispatch_after

我們經(jīng)常會遇到這樣的需求：在指定時間（例如 3 秒）之后執(zhí)行某個任務。可以用 GCD 的dispatch_after 方法來實現(xiàn)。
需要注意的是：dispatch_after 方法并不是在指定時間之后才開始執(zhí)行處理，而是在指定時間之后將任務追加到主隊列中。嚴格來說，這個時間并不是絕對準確的，但想要大致延遲執(zhí)行任務，dispatch_after 方法是很有效的。

/*** 延時執(zhí)行方法 dispatch_after*/ - (void)after {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"asyncMain---begin");dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{// 2.0 秒后異步追加任務代碼到主隊列，并開始執(zhí)行NSLog(@"after---%@",[NSThread currentThread]); // 打印當前線程}); }

輸出結(jié)果：
?currentThread---<NSThread: 0x600003c45270>{number = 1, name = main}
?asyncMain---begin
?after---<NSThread: 0x600003c45270>{number = 1, name = main}

5.3 GCD 一次性代碼（只執(zhí)行一次）：dispatch_once

我們在創(chuàng)建單例、或者有整個程序運行過程中只執(zhí)行一次的代碼時，我們就用到了 GCD 的 dispatch_once 方法。使用 dispatch_once 方法能保證某段代碼在程序運行過程中只被執(zhí)行 1 次，并且即使在多線程的環(huán)境下，dispatch_once 也可以保證線程安全。

/*** 一次性代碼（只執(zhí)行一次）dispatch_once*/ - (void)once {static dispatch_once_t onceToken;dispatch_once(&onceToken, ^{// 只執(zhí)行 1 次的代碼（這里面默認是線程安全的）}); }

5.4 GCD 快速迭代方法：dispatch_apply

通常我們會用 for 循環(huán)遍歷，但是 GCD 給我們提供了快速迭代的方法 dispatch_apply。dispatch_apply 按照指定的次數(shù)將指定的任務追加到指定的隊列中，并等待全部隊列執(zhí)行結(jié)束。

如果是在串行隊列中使用 dispatch_apply，那么就和 for 循環(huán)一樣，按順序同步執(zhí)行。但是這樣就體現(xiàn)不出快速迭代的意義了。

我們可以利用并發(fā)隊列進行異步執(zhí)行。比如說遍歷 0~5 這 6 個數(shù)字，for 循環(huán)的做法是每次取出一個元素，逐個遍歷。dispatch_apply 可以在多個線程中同時（異步）遍歷多個數(shù)字。

還有一點，無論是在串行隊列，還是并發(fā)隊列中，dispatch_apply 都會等待全部任務執(zhí)行完畢，這點就像是同步操作，也像是隊列組中的 dispatch_group_wait方法。

/*** 快速迭代方法 dispatch_apply*/ - (void)apply {dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);NSLog(@"apply---begin");dispatch_apply(6, queue, ^(size_t index) {NSLog(@"%zd---%@",index, [NSThread currentThread]);});NSLog(@"apply---end"); }

因為是在并發(fā)隊列中異步執(zhí)行任務，所以各個任務的執(zhí)行時間長短不定，最后結(jié)束順序也不定。但是?apply---end?一定在最后執(zhí)行。這是因為?dispatch_apply?方法會等待全部任務執(zhí)行完畢。

5.5 GCD 隊列組：dispatch_group

有時候我們會有這樣的需求：分別異步執(zhí)行2個耗時任務，然后當2個耗時任務都執(zhí)行完畢后再回到主線程執(zhí)行任務。這時候我們可以用到 GCD 的隊列組。

調(diào)用隊列組的 dispatch_group_async 先把任務放到隊列中，然后將隊列放入隊列組中。或者使用隊列組的 dispatch_group_enter、dispatch_group_leave 組合來實現(xiàn) dispatch_group_async。
調(diào)用隊列組的 dispatch_group_notify 回到指定線程執(zhí)行任務。或者使用 dispatch_group_wait 回到當前線程繼續(xù)向下執(zhí)行（會阻塞當前線程）。

5.5.1 dispatch_group_notify

監(jiān)聽 group 中任務的完成狀態(tài)，當所有的任務都執(zhí)行完成后，追加任務到 group 中，并執(zhí)行任務。

/*** 隊列組 dispatch_group_notify*/ - (void)groupNotify {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"group---begin");dispatch_group_t group = dispatch_group_create();dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{// 追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程});dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{// 追加任務 2[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程});dispatch_group_notify(group, dispatch_get_main_queue(), ^{// 等前面的異步任務 1、任務 2 都執(zhí)行完畢后，回到主線程執(zhí)行下邊任務[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"group---end");}); }

輸出結(jié)果：
?currentThread---<NSThread: 0x600005c4567ea0>{number = 1, name = main}
?group---begin
?2---<NSThread: 0x600005c64a33c0>{number = 4, name = (null)}
?1---<NSThread: 0x600005c53ea210>{number = 3, name = (null)}
?3---<NSThread: 0x600005c4567ea0>{number = 1, name = main}
?group---end

從?dispatch_group_notify?相關(guān)代碼運行輸出結(jié)果可以看出：
當所有任務都執(zhí)行完成之后，才執(zhí)行?dispatch_group_notify?相關(guān) block 中的任務。

5.5.2 dispatch_group_wait

暫停當前線程（阻塞當前線程），等待指定的 group 中的任務執(zhí)行完成后，才會往下繼續(xù)執(zhí)行。

/*** 隊列組 dispatch_group_wait*/ - (void)groupWait {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"group---begin");dispatch_group_t group = dispatch_group_create();dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{// 追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程});dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{// 追加任務 2[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程});// 等待上面的任務全部完成后，會往下繼續(xù)執(zhí)行（會阻塞當前線程）dispatch_group_wait(group, DISPATCH_TIME_FOREVER);NSLog(@"group---end");}

輸出結(jié)果：
?currentThread---<NSThread: 0x6000032a5680>{number = 1, name = main}
?group---begin
?2---<NSThread: 0x6000032e2440>{number = 4, name = (null)}
?1---<NSThread: 0x6000032c5630>{number = 3, name = (null)}
?group---end

從 dispatch_group_wait 相關(guān)代碼運行輸出結(jié)果可以看出：
當所有任務執(zhí)行完成之后，才執(zhí)行 dispatch_group_wait 之后的操作。但是，使用dispatch_group_wait 會阻塞當前線程。

5.5.3 dispatch_group_enter、dispatch_group_leave

dispatch_group_enter 標志著一個任務追加到 group，執(zhí)行一次，相當于 group 中未執(zhí)行完畢任務數(shù) +1
dispatch_group_leave 標志著一個任務離開了 group，執(zhí)行一次，相當于 group 中未執(zhí)行完畢任務數(shù) -1。
當 group 中未執(zhí)行完畢任務數(shù)為0的時候，才會使 dispatch_group_wait 解除阻塞，以及執(zhí)行追加到 dispatch_group_notify 中的任務。

/*** 隊列組 dispatch_group_enter、dispatch_group_leave*/ - (void)groupEnterAndLeave {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"group---begin");dispatch_group_t group = dispatch_group_create();dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);dispatch_group_enter(group);dispatch_async(queue, ^{// 追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程dispatch_group_leave(group);});dispatch_group_enter(group);dispatch_async(queue, ^{// 追加任務 2[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"2---%@",[NSThread currentThread]); // 打印當前線程dispatch_group_leave(group);});dispatch_group_notify(group, dispatch_get_main_queue(), ^{// 等前面的異步操作都執(zhí)行完畢后，回到主線程.[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"group---end");}); }

輸出結(jié)果：
?currentThread---<NSThread: 0x600006ac6730>{number = 1, name = main}
?group---begin
?2---<NSThread: 0x600006a23240>{number = 3, name = (null)}
?1---<NSThread: 0x600006a56460>{number = 4, name = (null)}
?3---<NSThread: 0x600006ac6730>{number = 1, name = main}
?group---end

從 dispatch_group_enter、dispatch_group_leave 相關(guān)代碼運行結(jié)果中可以看出：當所有任務執(zhí)行完成之后，才執(zhí)行 dispatch_group_notify 中的任務。這里的dispatch_group_enter、dispatch_group_leave 組合，其實等同于dispatch_group_async。

5.6 GCD 信號量：dispatch_semaphore

GCD 中的信號量是指 Dispatch Semaphore，是持有計數(shù)的信號。類似于過高速路收費站的欄桿。可以通過時，打開欄桿，不可以通過時，關(guān)閉欄桿。在 Dispatch Semaphore 中，使用計數(shù)來完成這個功能，計數(shù)小于 0 時等待，不可通過。計數(shù)為 0 或大于 0 時，計數(shù)減 1 且不等待，可通過。

Dispatch Semaphore?提供了三個方法：

dispatch_semaphore_create：創(chuàng)建一個 Semaphore 并初始化信號的總量
dispatch_semaphore_signal：發(fā)送一個信號，讓信號總量加 1
dispatch_semaphore_wait：可以使總信號量減 1，信號總量小于 0 時就會一直等待（阻塞所在線程），否則就可以正常執(zhí)行。

注意：信號量的使用前提是：想清楚你需要處理哪個線程等待（阻塞），又要哪個線程繼續(xù)執(zhí)行，然后使用信號量。

Dispatch Semaphore 在實際開發(fā)中主要用于：

保持線程同步，將異步執(zhí)行任務轉(zhuǎn)換為同步執(zhí)行任務
保證線程安全，為線程加鎖

5.6.1 Dispatch Semaphore 線程同步

我們在開發(fā)中，會遇到這樣的需求：異步執(zhí)行耗時任務，并使用異步執(zhí)行的結(jié)果進行一些額外的操作。換句話說，相當于，將將異步執(zhí)行任務轉(zhuǎn)換為同步執(zhí)行任務。比如說：AFNetworking 中 AFURLSessionManager.m 里面的 tasksForKeyPath: 方法。通過引入信號量的方式，等待異步執(zhí)行任務結(jié)果，獲取到 tasks，然后再返回該 tasks。

- (NSArray *)tasksForKeyPath:(NSString *)keyPath {__block NSArray *tasks = nil;dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);[self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {tasks = dataTasks;} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {tasks = uploadTasks;} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {tasks = downloadTasks;} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];}dispatch_semaphore_signal(semaphore);}];dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);return tasks; }

下面，我們來利用 Dispatch Semaphore 實現(xiàn)線程同步，將異步執(zhí)行任務轉(zhuǎn)換為同步執(zhí)行任務。

/*** semaphore 線程同步*/ - (void)semaphoreSync {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"semaphore---begin");dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);__block int number = 0;dispatch_async(queue, ^{// 追加任務 1[NSThread sleepForTimeInterval:2]; // 模擬耗時操作NSLog(@"1---%@",[NSThread currentThread]); // 打印當前線程number = 100;dispatch_semaphore_signal(semaphore);});dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);NSLog(@"semaphore---end,number = %zd",number); }

輸出結(jié)果：
?currentThread---<NSThread: 0x60000567a530>{number = 1, name = main}
?semaphore---begin
?1---<NSThread: 0x6000057ea540>{number = 3, name = (null)}
?semaphore---end,number = 100

從 Dispatch Semaphore 實現(xiàn)線程同步的代碼可以看到：

semaphore---end 是在執(zhí)行完 number = 100; 之后才打印的。而且輸出結(jié)果 number 為 100。這是因為異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務。
執(zhí)行順如下：

semaphore 初始創(chuàng)建時計數(shù)為 0。

異步執(zhí)行將任務 1 追加到隊列之后，不做等待，接著執(zhí)行 dispatch_semaphore_wait 方法，semaphore 減 1，此時 semaphore == -1，當前線程進入等待狀態(tài)。

然后，異步任務 1 開始執(zhí)行。任務 1 執(zhí)行到 dispatch_semaphore_signal 之后，總信號量加 1，此時 semaphore == 0，正在被阻塞的線程（主線程）恢復繼續(xù)執(zhí)行。

最后打印 semaphore---end,number = 100。

這樣就實現(xiàn)了線程同步，將異步執(zhí)行任務轉(zhuǎn)換為同步執(zhí)行任務。

5.6.2 Dispatch Semaphore 線程安全和線程同步（為線程加鎖）

線程安全：如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結(jié)果和單線程運行的結(jié)果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。

若每個線程中對全局變量、靜態(tài)變量只有讀操作，而無寫操作，一般來說，這個全局變量是線程安全的；若有多個線程同時執(zhí)行寫操作（更改變量），一般都需要考慮線程同步，否則的話就可能影響線程安全。

線程同步：可理解為線程 A 和線程 B 一塊配合，A 執(zhí)行到一定程度時要依靠線程 B 的某個結(jié)果，于是停下來，示意 B 運行；B 依言執(zhí)行，再將結(jié)果給 A；A 再繼續(xù)操作。

舉個簡單例子就是：兩個人在一起聊天。兩個人不能同時說話，避免聽不清(操作沖突)。等一個人說完(一個線程結(jié)束操作)，另一個再說(另一個線程再開始操作)。

下面，我們模擬火車票售賣的方式，實現(xiàn) NSThread 線程安全和解決線程同步問題。

場景：總共有 100 張火車票，有兩個售賣火車票的窗口，一個是北京火車票售賣窗口，另一個是上海火車票售賣窗口。兩個窗口同時售賣火車票，賣完為止。

5.6.2.1 非線程安全（不使用 semaphore）

先來看看不考慮線程安全的代碼：

/*** 非線程安全：不使用 semaphore* 初始化火車票數(shù)量、賣票窗口（非線程安全）、并開始賣票*/ - (void)initTicketStatusNotSave {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"semaphore---begin");self.ticketSurplusCount = 100;// queue1 代表北京火車票售賣窗口dispatch_queue_t queue1 = dispatch_queue_create("com.hiccup.myQueue1", DISPATCH_QUEUE_SERIAL);// queue2 代表上海火車票售賣窗口dispatch_queue_t queue2 = dispatch_queue_create("com.hiccup.myQueue2", DISPATCH_QUEUE_SERIAL);__weak typeof(self) weakSelf = self;dispatch_async(queue1, ^{[weakSelf saleTicketNotSafe];});dispatch_async(queue2, ^{[weakSelf saleTicketNotSafe];}); }/*** 售賣火車票（非線程安全）*/ - (void)saleTicketNotSafe {while (1) {if (self.ticketSurplusCount > 0) { // 如果還有票，繼續(xù)售賣self.ticketSurplusCount--;NSLog(@"%@", [NSString stringWithFormat:@"剩余票數(shù)：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);[NSThread sleepForTimeInterval:0.2];} else { // 如果已賣完，關(guān)閉售票窗口NSLog(@"所有火車票均已售完");break;}} }

輸出結(jié)果（部分）：
?currentThread---<NSThread: 0x6000056787a0>{number = 1, name = main}
?semaphore---begin
?剩余票數(shù)：98 窗口：<NSThread: 0x6000015cc600>{number = 4, name = (null)}
?剩余票數(shù)：99 窗口：<NSThread: 0x6000015f8600>{number = 3, name = (null)}
?剩余票數(shù)：97 窗口：<NSThread: 0x6000015f8600>{number = 3, name = (null)}
?剩余票數(shù)：947 窗口：<NSThread: 0x6000015cc600>{number = 4, name = (null)}
?剩余票數(shù)：96 窗口：<NSThread: 0x6000015cc600>{number = 4, name = (null)}
...

可以看到在不考慮線程安全，不使用 semaphore 的情況下，得到票數(shù)是錯亂的，這樣顯然不符合我們的需求，所以我們需要考慮線程安全問題。

5.6.2.2 線程安全（使用 semaphore 加鎖）

考慮線程安全的代碼：

/*** 線程安全：使用 semaphore 加鎖* 初始化火車票數(shù)量、賣票窗口（線程安全）、并開始賣票*/ - (void)initTicketStatusSave {NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程NSLog(@"semaphore---begin");semaphoreLock = dispatch_semaphore_create(1);self.ticketSurplusCount = 100;// queue1 代表北京火車票售賣窗口dispatch_queue_t queue1 = dispatch_queue_create("com.hiccup.myQueue1", DISPATCH_QUEUE_SERIAL);// queue2 代表上海火車票售賣窗口dispatch_queue_t queue2 = dispatch_queue_create("com.hiccup.myQueue2", DISPATCH_QUEUE_SERIAL);__weak typeof(self) weakSelf = self;dispatch_async(queue1, ^{[weakSelf saleTicketSafe];});dispatch_async(queue2, ^{[weakSelf saleTicketSafe];}); }/*** 售賣火車票（線程安全）*/ - (void)saleTicketSafe {while (1) {// 相當于加鎖dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);if (self.ticketSurplusCount > 0) { // 如果還有票，繼續(xù)售賣self.ticketSurplusCount--;NSLog(@"%@", [NSString stringWithFormat:@"剩余票數(shù)：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);[NSThread sleepForTimeInterval:0.2];} else { // 如果已賣完，關(guān)閉售票窗口NSLog(@"所有火車票均已售完");// 相當于解鎖dispatch_semaphore_signal(semaphoreLock);break;}// 相當于解鎖dispatch_semaphore_signal(semaphoreLock);} }

輸出結(jié)果為：
?currentThread---<NSThread: 0x600000681380>{number = 1, name = main}
?semaphore---begin
?剩余票數(shù)：49 窗口：<NSThread: 0x6000006ede80>{number = 3, name = (null)}
?剩余票數(shù)：48 窗口：<NSThread: 0x6000006e4b40>{number = 4, name = (null)}
...
?剩余票數(shù)：1 窗口：<NSThread: 0x6000006ede80>{number = 3, name = (null)}
?剩余票數(shù)：0 窗口：<NSThread: 0x6000006e4b40>{number = 4, name = (null)}
?所有火車票均已售完
?所有火車票均已售完

可以看出，在考慮了線程安全的情況下，使用?dispatch_semaphore?機制之后，得到的票數(shù)是正確的，沒有出現(xiàn)混亂的情況。我們也就解決了多個線程同步的問題。

參考資料：

書籍：『Objective-C 高級編程 iOS 與 OS X 多線程和內(nèi)存管理』
博文：iOS GCD 之 dispatch_semaphore（信號量）

總結(jié)

以上是生活随笔為你收集整理的iOS进阶 - GCD总结的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。

上一篇： Symbol 函数
下一篇：万有引力的意思_万有引力的本质是什么？