整理多執行緒:GCD詳解
阿新 • • 發佈：2019-12-25
一、GCD簡介
Grand Central Dispatch(GCD) 是 Apple 開發的一個多核程式設計的較新的解決方法。
它主要用於優化應用程式以支援多核處理器以及其他對稱多處理系統。是一個線上程池模式的基礎上執行的併發任務
複製程式碼為什麼要用 GCD 呢？
1. GCD 可用於多核的並行運算
2. GCD 會自動利用更多的 CPU 核心（比如雙核、四核）
3. GCD 會自動管理執行緒的生命週期（建立執行緒、排程任務、銷燬執行緒）
4. 程式設計師只需要告訴GCD想要執行什麼任務，不需要編寫任何執行緒管理程式碼
複製程式碼二、GCD 任務和佇列
2.1 任務
任務就是執行操作的意思，也就是線上程中所需要執行的那段程式碼，在GCD中的block中實現。
複製程式碼 執行任務分為兩種方式: 同步執行 (sync) 和 非同步執行 (async)
同步執行
1.同步新增任務到指定的佇列中，在新增的任務執行結束之前，會一直等待，直到佇列裡面的任務完成之後再繼續執行。
2.只能在當前執行緒中執行任務，不具備開啟新執行緒的能力。
複製程式碼非同步執行
1.非同步新增任務到指定的佇列中，它不會做任何等待，可以繼續執行任務。
2.可以在新的執行緒中執行任務，具備開啟新執行緒的能力。
複製程式碼區別
是否等待佇列的任務執行結束，以及是否具備開啟新執行緒的能力
複製程式碼2.2 佇列（Dispatch Queue）
指執行任務的等待佇列，即用來存放任務的佇列。
佇列是一種特殊的線性表，採用FIFO（先進先出）的原則，即新任務總是被插入到佇列的末尾，而讀取任務的時候總是從佇列的頭部開始讀取。
每讀取一個任務，則從佇列中釋放一個任務。
複製程式碼 如圖:
在GCD中有兩種佇列:
序列佇列（Serial Dispatch Queue）
每次只有一個任務被執行。讓任務一個接著一個地執行。（只開啟一個執行緒，一個任務執行完畢後，再執行下一個任務）
複製程式碼併發佇列（Concurrent Dispatch Queue）
可以讓多個任務併發（同時）執行。（可以開啟多個執行緒，並且同時執行任務）
複製程式碼注意：併發佇列 的併發功能只有在非同步（dispatch_async）函式下才有效
複製程式碼區別：
執行順序不同，以及開啟執行緒數不同
複製程式碼兩者具體區別如下兩圖所示：
三、GCD的使用步驟
GCD 的使用步驟其實很簡單，只有兩步:
1.建立一個佇列（序列佇列或併發佇列）
2.將任務追加到任務的等待佇列中，然後系統就會根據任務型別執行任務（同步執行或非同步執行
複製程式碼3.1 佇列的建立和獲取
dispatch_queue_create
使用 dispatch_queue_create 來建立佇列，需要傳入兩個引數:
1. 第一個引數表示佇列的唯一識別符號，用於 DEBUG，可為空，Dispatch Queue 的名稱推薦使用應用程式 ID 這種逆序全程域名
2. 第二個引數用來識別是序列佇列還是併發佇列。DISPATCH_QUEUE_SERIAL 表示序列佇列，DISPATCH_QUEUE_CONCURRENT 表示併發佇列
複製程式碼方法如下：
// 序列佇列的建立方法
dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue",DISPATCH_QUEUE_SERIAL);
// 併發佇列的建立方法
dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue",DISPATCH_QUEUE_CONCURRENT);
複製程式碼主佇列（Main Dispatch Queue）
主佇列屬於GCD中的一種特殊的序列佇列，主要有以下特點：
1. 所有放在主佇列中的任務，都會放到主執行緒中執行。
2.可使用 dispatch_get_main_queue() 獲得主佇列。
複製程式碼獲取方法：
// 主佇列的獲取方法
dispatch_queue_t queue = dispatch_get_main_queue();
複製程式碼全域性併發佇列（Global Dispatch Queue）
在併發佇列中使用，可以使用dispatch_get_global_queue 來獲取。需要傳入兩個引數:
1.第一個引數表示佇列優先順序，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。
2.第二個引數暫時沒用，用0即可
複製程式碼獲取方法：
// 全域性併發佇列的獲取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
複製程式碼3.2 任務的建立方法
GCD 提供了同步執行任務的建立方法dispatch_sync和非同步執行任務建立方法dispatch_async
// 同步執行任務建立方法
dispatch_sync(queue,^{
// 這裡放同步執行任務程式碼
});
// 非同步執行任務建立方法
dispatch_async(queue,^{
// 這裡放非同步執行任務程式碼
});
複製程式碼雖然使用 GCD 只需兩步，但是既然我們有兩種佇列（序列佇列/併發佇列），兩種任務執行方式（同步執行/非同步執行），那麼我們就有了四種不同的組合方式。這四種不同的組合方式是：
1. 同步執行 + 併發佇列
2. 非同步執行 + 併發佇列
3. 同步執行 + 序列佇列
4. 非同步執行 + 序列佇列
複製程式碼實際上，剛才還說了兩種特殊佇列：全域性併發佇列、主佇列。全域性併發佇列可以作為普通併發佇列來使用。但是主佇列因為有點特殊，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了
5. 同步執行 + 主佇列
6. 非同步執行 + 主佇列
複製程式碼不同組合方式之間的區別:
| 區別 | 序列佇列 | 併發佇列 | 主佇列 |
|---|---|---|---|
| 同步(sync) | 沒有開啟新執行緒，序列執行任務 | 沒有開啟新執行緒，序列執行任務 | 沒有開啟新執行緒，序列執行任務 |
| 非同步(async) | 有開啟新執行緒(1條)，序列執行任務 | 有開啟新執行緒，併發執行任務 | 沒有開啟新執行緒，序列執行任務 |
四、GCD的基本使用
4.1、同步執行 + 併發佇列
在當前執行緒中執行任務，不會開啟新執行緒，執行完一個任務，再執行下一個任務。
/**
* 同步執行 + 併發佇列
* 特點：在當前執行緒中執行任務，不會開啟新執行緒，執行完一個任務，再執行下一個任務。
*/
- (void)syncConcurrentTask{
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"syncConcurrentTask : begin");
dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue",DISPATCH_QUEUE_CONCURRENT);
//任務1
dispatch_sync(queue,^{
for (NSInteger index = 0; index < 2; index ++ ) {
[NSThread sleepForTimeInterval:2]; // 休眠2s，模擬耗時操作
NSLog(@"任務1執行緒: %@",[NSThread currentThread]); // 列印當前執行緒
}
});
//任務2
dispatch_sync(queue,^{
for (NSInteger index = 0; index < 2; index ++ ) {
[NSThread sleepForTimeInterval:2]; // 休眠2s，模擬耗時操作
NSLog(@"任務2執行緒: %@",[NSThread currentThread]); // 列印當前執行緒
}
});
//任務3
dispatch_sync(queue,^{
for (NSInteger index = 0; index < 2; index ++ ) {
[NSThread sleepForTimeInterval:2]; // 休眠2s，模擬耗時操作
NSLog(@"任務3執行緒: %@",[NSThread currentThread]); // 列印當前執行緒
}
});
NSLog(@"syncConcurrentTask : end");
}
日誌輸出:
2019-08-15 11:37:01.882803+0800 XKHttpNetworkHelper[31452:1205128] 當前執行緒 : <NSThread: 0x600002901300>{number = 1,name = main}
2019-08-15 11:37:01.882926+0800 XKHttpNetworkHelper[31452:1205128] syncConcurrentTask : begin
2019-08-15 11:37:03.883808+0800 XKHttpNetworkHelper[31452:1205128] 任務1執行緒: <NSThread: 0x600002901300>{number = 1,name = main}
2019-08-15 11:37:05.884233+0800 XKHttpNetworkHelper[31452:1205128] 任務1執行緒: <NSThread: 0x600002901300>{number = 1,name = main}
2019-08-15 11:37:07.884623+0800 XKHttpNetworkHelper[31452:1205128] 任務2執行緒: <NSThread: 0x600002901300>{number = 1,name = main}
2019-08-15 11:37:10.057093+0800 XKHttpNetworkHelper[31452:1205128] 任務2執行緒: <NSThread: 0x600002901300>{number = 1,name = main}
2019-08-15 11:37:12.057729+0800 XKHttpNetworkHelper[31452:1205128] 任務3執行緒: <NSThread: 0x600002901300>{number = 1,name = main}
2019-08-15 11:37:14.058287+0800 XKHttpNetworkHelper[31452:1205128] 任務3執行緒: <NSThread: 0x600002901300>{number = 1,name = main}
2019-08-15 11:37:14.058435+0800 XKHttpNetworkHelper[31452:1205128] syncConcurrentTask : end
複製程式碼從執行 (同步執行 + 併發佇列) 任務的輸出日誌中可以看到:
1. 所有任務都是在當前執行緒（主執行緒）中執行的，沒有開啟新的執行緒（同步執行不具備開啟新執行緒的能力。
2. 所有任務都在列印的syncConcurrentTask:begin和syncConcurrentTask:end之間執行的（同步任務需要等待佇列的任務執行結束）。
3. 任務按順序執行的。
按順序執行的原因：雖然併發佇列可以開啟多個執行緒，並且同時執行多個任務。
但是因為本身不能建立新執行緒，只有當前執行緒這一個執行緒（同步任務不具備開啟新執行緒的能力），所以也就不存在併發。
而且當前執行緒只有等待當前佇列中正在執行的任務執行完畢之後，才能繼續接著執行下面的操作（同步任務需要等待佇列的任務執行結束）。
所以任務只能一個接一個按順序執行，不能同時被執行
複製程式碼4.2、非同步執行 + 併發佇列
可以開啟多個執行緒，，任務交替(同時)執行
/**
* 非同步執行 + 併發佇列
* 特點：可以開啟多個執行緒，任務交替（同時）執行。
*/
- (void)asyncConcurrentTask {
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"asyncConcurrentTask : begin");
dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue",DISPATCH_QUEUE_CONCURRENT);
//任務1
dispatch_async(queue,[NSThread currentThread]); // 列印當前執行緒
}
});
//任務2
dispatch_async(queue,[NSThread currentThread]); // 列印當前執行緒
}
});
//任務3
dispatch_async(queue,[NSThread currentThread]); // 列印當前執行緒
}
});
NSLog(@"asyncConcurrentTask : end");
}
日誌輸出:
2019-08-15 13:53:45.774625+0800 XKHttpNetworkHelper[33086:1319354] 當前執行緒 : <NSThread: 0x600000712340>{number = 1,name = main}
2019-08-15 13:53:45.774757+0800 XKHttpNetworkHelper[33086:1319354] asyncConcurrentTask : begin
2019-08-15 13:53:45.774857+0800 XKHttpNetworkHelper[33086:1319354] asyncConcurrentTask : end
2019-08-15 13:53:47.778932+0800 XKHttpNetworkHelper[33086:1319430] 任務3執行緒: <NSThread: 0x60000074c040>{number = 3,name = (null)}
2019-08-15 13:53:47.778932+0800 XKHttpNetworkHelper[33086:1319431] 任務2執行緒: <NSThread: 0x600000750180>{number = 5,name = (null)}
2019-08-15 13:53:47.778932+0800 XKHttpNetworkHelper[33086:1319432] 任務1執行緒: <NSThread: 0x600000769000>{number = 4,name = (null)}
2019-08-15 13:53:49.784350+0800 XKHttpNetworkHelper[33086:1319432] 任務1執行緒: <NSThread: 0x600000769000>{number = 4,name = (null)}
2019-08-15 13:53:49.784341+0800 XKHttpNetworkHelper[33086:1319430] 任務3執行緒: <NSThread: 0x60000074c040>{number = 3,name = (null)}
2019-08-15 13:53:49.784359+0800 XKHttpNetworkHelper[33086:1319431] 任務2執行緒: <NSThread: 0x600000750180>{number = 5,name = (null)}
複製程式碼從執行 (非同步執行 + 併發佇列) 任務的輸出日誌中可以看到:
1. 除了當前執行緒（主執行緒），系統又開啟了3個執行緒，並且任務是交替/同時執行的。（非同步執行具備開啟新執行緒的能力。且併發佇列可開啟多個執行緒，同時執行多個任務）
2. 所有任務都在列印的asyncConcurrentTask:begin和asyncConcurrentTask:end之後執行的。說明當前執行緒沒有等待，而是直接開啟了新執行緒，在新執行緒中執行任務(非同步執行不必等待，可以繼續執行任務)
複製程式碼4.3、同步執行 + 序列佇列
不會開啟新執行緒，在當前執行緒執行任務。任務是序列的，執行完一個任務，再執行下一個任務
/**
* 同步執行 + 序列佇列
* 特點：不會開啟新執行緒，在當前執行緒執行任務。任務是序列的，執行完一個任務，再執行下一個任務。
*/
- (void)syncSerialTask{
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"syncSerialTask : begin");
dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue",DISPATCH_QUEUE_SERIAL);
//任務1
dispatch_sync(queue,[NSThread currentThread]); // 列印當前執行緒
}
});
NSLog(@"syncSerialTask : end");
}
日誌輸出:
2019-08-15 14:17:24.193189+0800 XKHttpNetworkHelper[33428:1377743] 當前執行緒 : <NSThread: 0x6000009c1480>{number = 1,name = main}
2019-08-15 14:17:24.193313+0800 XKHttpNetworkHelper[33428:1377743] syncSerialTask : begin
2019-08-15 14:17:26.194075+0800 XKHttpNetworkHelper[33428:1377743] 任務1執行緒: <NSThread: 0x6000009c1480>{number = 1,name = main}
2019-08-15 14:17:28.194587+0800 XKHttpNetworkHelper[33428:1377743] 任務1執行緒: <NSThread: 0x6000009c1480>{number = 1,name = main}
2019-08-15 14:17:30.195848+0800 XKHttpNetworkHelper[33428:1377743] 任務2執行緒: <NSThread: 0x6000009c1480>{number = 1,name = main}
2019-08-15 14:17:32.196502+0800 XKHttpNetworkHelper[33428:1377743] 任務2執行緒: <NSThread: 0x6000009c1480>{number = 1,name = main}
2019-08-15 14:17:34.196834+0800 XKHttpNetworkHelper[33428:1377743] 任務3執行緒: <NSThread: 0x6000009c1480>{number = 1,name = main}
2019-08-15 14:17:36.197151+0800 XKHttpNetworkHelper[33428:1377743] 任務3執行緒: <NSThread: 0x6000009c1480>{number = 1,name = main}
2019-08-15 14:17:36.197387+0800 XKHttpNetworkHelper[33428:1377743] syncSerialTask : end
複製程式碼從執行 (同步執行 + 序列佇列) 任務的輸出日誌中可以看到:
1. 所有任務都是在當前執行緒（主執行緒）中執行的，並沒有開啟新的執行緒（同步執行不具備開啟新執行緒的能力）。
2. 所有任務都在列印的syncSerialTask: begin和syncSerialTask : end之間執行（同步任務需要等待佇列的任務執行結束）。
3. 任務是按順序執行的（序列佇列每次只有一個任務被執行，任務一個接一個按順序執行）。
複製程式碼4.4、非同步執行 + 序列佇列
會開啟新執行緒，但是因為任務是序列的，執行完一個任務，再執行下一個任務
/**
* 非同步執行 + 序列佇列
* 特點：會開啟新執行緒，但是因為任務是序列的，執行完一個任務，再執行下一個任務。
*/
- (void)asyncSerialTask {
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"asyncSerialTask : begin");
dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue",DISPATCH_QUEUE_SERIAL);
//任務1
dispatch_async(queue,[NSThread currentThread]); // 列印當前執行緒
}
});
NSLog(@"asyncSerialTask : end");
}
日誌輸出:
2019-08-15 14:23:59.070912+0800 XKHttpNetworkHelper[33542:1394792] 當前執行緒 : <NSThread: 0x600002554d00>{number = 1,name = main}
2019-08-15 14:23:59.071072+0800 XKHttpNetworkHelper[33542:1394792] asyncSerialTask : begin
2019-08-15 14:23:59.071207+0800 XKHttpNetworkHelper[33542:1394792] asyncSerialTask : end
2019-08-15 14:24:01.076086+0800 XKHttpNetworkHelper[33542:1394881] 任務1執行緒: <NSThread: 0x60000251b9c0>{number = 3,name = (null)}
2019-08-15 14:24:03.080528+0800 XKHttpNetworkHelper[33542:1394881] 任務1執行緒: <NSThread: 0x60000251b9c0>{number = 3,name = (null)}
2019-08-15 14:24:05.085977+0800 XKHttpNetworkHelper[33542:1394881] 任務2執行緒: <NSThread: 0x60000251b9c0>{number = 3,name = (null)}
2019-08-15 14:24:07.091084+0800 XKHttpNetworkHelper[33542:1394881] 任務2執行緒: <NSThread: 0x60000251b9c0>{number = 3,name = (null)}
2019-08-15 14:24:09.094797+0800 XKHttpNetworkHelper[33542:1394881] 任務3執行緒: <NSThread: 0x60000251b9c0>{number = 3,name = (null)}
2019-08-15 14:24:11.097145+0800 XKHttpNetworkHelper[33542:1394881] 任務3執行緒: <NSThread: 0x60000251b9c0>{number = 3,name = (null)}
複製程式碼從執行 (非同步執行 + 序列佇列) 任務的輸出日誌中可以看到:
1. 開啟了一條新執行緒（非同步執行具備開啟新執行緒的能力，序列佇列只開啟一個執行緒）。
2. 所有任務是在列印的asyncSerialTask : begin和asyncSerialTask : end之後才開始執行的（非同步執行不會做任何等待，可以繼續執行任務）。
3. 任務是按順序執行的（序列佇列每次只有一個任務被執行，任務一個接一個按順序執行）。
複製程式碼4.5、同步執行 + 主佇列
主佇列: GCD自帶的一種特殊的序列佇列
1. 所有放在主佇列中的任務，都會放到主執行緒中執行
2. 可使用dispatch_get_main_queue()獲得主佇列
複製程式碼注意:
同步執行 + 主佇列在不同執行緒中呼叫結果也是不一樣，在主執行緒中呼叫會出現死鎖，而在其他執行緒中則不會。
在這裡做一個解釋，導致死鎖的原因，是在同一個序列佇列任務中，兩個任務相互依賴所導致的，
並不侷限於同步執行 + 主佇列的模式，在這裡只是舉例說明。
複製程式碼在主執行緒中呼叫同步執行 + 主佇列
互相等待卡住不可行
/**
* 同步執行 + 主佇列
* 特點(主執行緒呼叫)：互等卡主不執行。
* 特點(其他執行緒呼叫)：不會開啟新執行緒，執行完一個任務，再執行下一個任務。
*/
- (void)syncMainTask{
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"syncMainTask : begin");
dispatch_queue_t queue = dispatch_get_main_queue();
//任務1
dispatch_sync(queue,[NSThread currentThread]); // 列印當前執行緒
}
});
NSLog(@"syncMainTask : end");
}
日誌輸出:
2019-08-15 14:30:36.746214+0800 XKHttpNetworkHelper[33641:1411969] 當前執行緒 : <NSThread: 0x6000013d40c0>{number = 1,name = main}
2019-08-15 14:30:36.746396+0800 XKHttpNetworkHelper[33641:1411969] syncMainTask : begin
(lldb)
複製程式碼從主執行緒執行 (同步執行 + 主佇列) 任務的輸出日誌中可以看到:
1. 在主執行緒中使用同步執行 + 主佇列，追加到主執行緒的任務1、任務2、任務3都不再執行了，syncMainTask: end也沒有列印
複製程式碼於此同時，在Xcode上執行該程式碼時，還會出現崩潰，這是為什麼呢?
答: 當在主執行緒中執行syncMainTask方法，相當於把syncMainTask 任務放到了主執行緒的佇列中。 而同步執行會等待當前佇列中的任務執行完畢，才會接著執行下一個任務。
那麼當把任務1追加到主佇列中，任務1就在等待主執行緒處理syncMainTask任務，而syncMainTask任務需要等待任務1執行完畢，才會接著執行。
那麼，當syncMainTask任務和任務1都在等待對方執行完畢，這就導致了執行緒卡住了，佇列中的任務也執行不了，所以也沒有列印syncMainTask: end
複製程式碼在其他執行緒中呼叫同步執行 + 主佇列
不會開啟新執行緒，執行完一個任務，再執行下一個任務。
// 使用 NSThread 的 detachNewThreadSelector 方法會建立執行緒，並自動啟動執行緒執行
[NSThread detachNewThreadSelector:@selector(syncMainTask) toTarget:self withObject:nil];
日誌輸出:
2019-08-15 14:38:37.113023+0800 XKHttpNetworkHelper[33757:1426643] 當前執行緒 : <NSThread: 0x600001269280>{number = 3,name = (null)}
2019-08-15 14:38:37.113231+0800 XKHttpNetworkHelper[33757:1426643] syncMainTask : begin
2019-08-15 14:38:39.124858+0800 XKHttpNetworkHelper[33757:1426494] 任務1執行緒: <NSThread: 0x600001216900>{number = 1,name = main}
2019-08-15 14:38:41.125326+0800 XKHttpNetworkHelper[33757:1426494] 任務1執行緒: <NSThread: 0x600001216900>{number = 1,name = main}
2019-08-15 14:38:43.127719+0800 XKHttpNetworkHelper[33757:1426494] 任務2執行緒: <NSThread: 0x600001216900>{number = 1,name = main}
2019-08-15 14:38:45.128980+0800 XKHttpNetworkHelper[33757:1426494] 任務2執行緒: <NSThread: 0x600001216900>{number = 1,name = main}
2019-08-15 14:38:47.131208+0800 XKHttpNetworkHelper[33757:1426494] 任務3執行緒: <NSThread: 0x600001216900>{number = 1,name = main}
2019-08-15 14:38:49.131635+0800 XKHttpNetworkHelper[33757:1426494] 任務3執行緒: <NSThread: 0x600001216900>{number = 1,name = main}
2019-08-15 14:38:49.132000+0800 XKHttpNetworkHelper[33757:1426643] syncMainTask : end
複製程式碼從其他執行緒執行 (同步執行 + 主佇列) 任務的輸出日誌中可以看到:
1. 所有任務都是在主執行緒（非當前執行緒）中執行的，沒有開啟新的執行緒（所有放在主佇列中的任務，都會放到主執行緒中執行）。
2. 所有任務都在列印的syncMainTask : begin和syncMainTask : end之間執行（同步任務需要等待佇列的任務執行結束）。
3. 任務是按順序執行的（主佇列是序列佇列，每次只有一個任務被執行，任務一個接一個按順序執行）。
複製程式碼為什麼在其他執行緒執行，就不會卡住了呢？
答： 因為 syncMainTask 放到了其他執行緒裡，而任務1、任務2、任務3都追加在主佇列中，這三個任務都會在主執行緒中執行。
syncMainTask任務在其他執行緒中執行追加到任務1到佇列中，因為主佇列現在沒有正在執行的任務，
所以，會直接執行主佇列的任務1，等任務1執行完畢，再接著執行任務2、任務3。所以這裡不會卡住執行緒。
複製程式碼4.5、非同步執行 + 主佇列
只在主執行緒中執行任務，執行完一個任務，再執行下一個任務。
/**
* 非同步執行 + 主佇列
* 特點：只在主執行緒中執行任務，執行完一個任務，再執行下一個任務
*/
- (void)asyncMainTask {
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"asyncMainTask : begin");
dispatch_queue_t queue = dispatch_get_main_queue();
//任務1
dispatch_async(queue,[NSThread currentThread]); // 列印當前執行緒
}
});
NSLog(@"asyncMainTask : end");
}
日誌輸出：
2019-08-15 14:47:20.946679+0800 XKHttpNetworkHelper[33880:1443430] 當前執行緒 : <NSThread: 0x6000031a0c40>{number = 1,name = main}
2019-08-15 14:47:20.946835+0800 XKHttpNetworkHelper[33880:1443430] asyncMainTask : begin
2019-08-15 14:47:20.946933+0800 XKHttpNetworkHelper[33880:1443430] asyncMainTask : end
2019-08-15 14:47:22.961664+0800 XKHttpNetworkHelper[33880:1443430] 任務1執行緒: <NSThread: 0x6000031a0c40>{number = 1,name = main}
2019-08-15 14:47:24.961989+0800 XKHttpNetworkHelper[33880:1443430] 任務1執行緒: <NSThread: 0x6000031a0c40>{number = 1,name = main}
2019-08-15 14:47:26.962337+0800 XKHttpNetworkHelper[33880:1443430] 任務2執行緒: <NSThread: 0x6000031a0c40>{number = 1,name = main}
2019-08-15 14:47:28.962802+0800 XKHttpNetworkHelper[33880:1443430] 任務2執行緒: <NSThread: 0x6000031a0c40>{number = 1,name = main}
2019-08-15 14:47:30.964399+0800 XKHttpNetworkHelper[33880:1443430] 任務3執行緒: <NSThread: 0x6000031a0c40>{number = 1,name = main}
2019-08-15 14:47:32.965105+0800 XKHttpNetworkHelper[33880:1443430] 任務3執行緒: <NSThread: 0x6000031a0c40>{number = 1,name = main}
複製程式碼從執行 (非同步執行 + 主佇列) 任務的輸出日誌中可以看到:
1. 所有任務都是在當前執行緒（主執行緒）中執行的，並沒有開啟新的執行緒（雖然非同步執行具備開啟執行緒的能力，但因為是主佇列，所以所有任務都在主執行緒中）。
2. 所有任務是在列印的syncConcurrent---begin和syncConcurrent---end之後才開始執行的（非同步執行不會做任何等待，可以繼續執行任務）。
3. 任務是按順序執行的（因為主佇列是序列佇列，每次只有一個任務被執行，任務一個接一個按順序執行）。
複製程式碼五、GCD執行緒間的通訊
在 iOS 開發過程中，我們一般在主執行緒裡邊進行 UI 重新整理，例如：點選、滾動、拖拽等事件。我們通常把一些耗時的操作放在其他執行緒，比如說圖片下載、檔案上傳等耗時操作。而當我們有時候在其他執行緒完成了耗時操作時，需要回到主執行緒，那麼就用到了執行緒之間的通訊。
/**
* 執行緒間通訊
*/
- (void)reloadDatas{
// 獲取全域性併發佇列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
// 獲取主佇列
dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_async(queue,^{
//非同步處理一些耗時操作的資料
for (NSInteger index = 0; index < 2; index ++ ) {
[NSThread sleepForTimeInterval:2]; // 休眠2s，模擬耗時操作
NSLog(@"非同步執行緒: %@",[NSThread currentThread]); // 列印當前執行緒
}
dispatch_async(mainQueue,^{
//主執行緒，更新UI等等
[NSThread sleepForTimeInterval:2]; // 休眠2s，模擬耗時操作
NSLog(@"主執行緒: %@",[NSThread currentThread]); // 列印當前執行緒
});
});
}
日誌輸出:
2019-08-15 14:53:19.932779+0800 XKHttpNetworkHelper[33980:1459145] 非同步執行緒: <NSThread: 0x600002500240>{number = 3,name = (null)}
2019-08-15 14:53:21.937532+0800 XKHttpNetworkHelper[33980:1459145] 非同步執行緒: <NSThread: 0x600002500240>{number = 3,name = (null)}
2019-08-15 14:53:23.937934+0800 XKHttpNetworkHelper[33980:1459058] 主執行緒: <NSThread: 0x600002572940>{number = 1,name = main}
複製程式碼從執行任務的結果上看:
1. 可以看到在其他執行緒中先執行任務，執行完了之後回到主執行緒執行主執行緒的相應操作。
複製程式碼六、GCD 的特殊方法
6.1 柵欄方法: dispatch_barrier_async
在日常開發過程中，有時候需要非同步執行兩組操作，而且第一組操作執行完之後，才能開始執行第二組操作。這樣我們就需要一個相當於 柵欄 一樣的一個方法將兩組非同步執行的操作組給分割起來，當然這裡的操作組裡可以包含一個或多個任務。這就需要用到 dispatch_barrier_async 方法在兩個操作組間形成柵欄。
dispatch_barrier_async 函式會等待前邊追加到併發佇列中的任務全部執行完畢之後，再將指定的任務追加到該非同步佇列中。
後在 dispatch_barrier_async 函式追加的任務執行完畢之後，非同步佇列才恢復為一般動作，接著追加任務到該非同步佇列並開始執行。
複製程式碼如圖：
/**
* 柵欄方法
*/
- (void)barrierAsyncTask{
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"barrierAsyncTask : begin");
dispatch_queue_t queue = dispatch_queue_create("net.gcd.testQueue",[NSThread currentThread]); // 列印當前執行緒
}
});
//柵欄方法
dispatch_barrier_async(queue,^{
for (NSInteger index = 0; index < 2; index ++ ) {
[NSThread sleepForTimeInterval:2]; // 休眠2s，模擬耗時操作
NSLog(@"柵欄方法 barrier: %@",[NSThread currentThread]); // 列印當前執行緒
}
});
//任務3
dispatch_async(queue,[NSThread currentThread]); // 列印當前執行緒
}
});
//任務4
dispatch_async(queue,^{
for (NSInteger index = 0; index < 2; index ++ ) {
[NSThread sleepForTimeInterval:2]; // 休眠2s，模擬耗時操作
NSLog(@"任務4執行緒: %@",[NSThread currentThread]); // 列印當前執行緒
}
});
NSLog(@"barrierAsyncTask : end");
}
日誌輸出:
2019-08-16 10:19:29.248058+0800 XKHttpNetworkHelper[1243:102722] 當前執行緒 : <NSThread: 0x6000016929c0>{number = 1,name = main}
2019-08-16 10:19:29.248226+0800 XKHttpNetworkHelper[1243:102722] barrierAsyncTask : begin
2019-08-16 10:19:29.248329+0800 XKHttpNetworkHelper[1243:102722] barrierAsyncTask : end
2019-08-16 10:19:31.252557+0800 XKHttpNetworkHelper[1243:103201] 任務1執行緒: <NSThread: 0x6000016c0080>{number = 3,name = (null)}
2019-08-16 10:19:31.252557+0800 XKHttpNetworkHelper[1243:103203] 任務2執行緒: <NSThread: 0x6000016fbc00>{number = 4,name = (null)}
2019-08-16 10:19:33.256810+0800 XKHttpNetworkHelper[1243:103203] 任務2執行緒: <NSThread: 0x6000016fbc00>{number = 4,name = (null)}
2019-08-16 10:19:33.256827+0800 XKHttpNetworkHelper[1243:103201] 任務1執行緒: <NSThread: 0x6000016c0080>{number = 3,name = (null)}
2019-08-16 10:19:35.260173+0800 XKHttpNetworkHelper[1243:103203] 柵欄方法 barrier: <NSThread: 0x6000016fbc00>{number = 4,name = (null)}
2019-08-16 10:19:37.262588+0800 XKHttpNetworkHelper[1243:103203] 柵欄方法 barrier: <NSThread: 0x6000016fbc00>{number = 4,name = (null)}
2019-08-16 10:19:39.266496+0800 XKHttpNetworkHelper[1243:103201] 任務4執行緒: <NSThread: 0x6000016c0080>{number = 3,name = (null)}
2019-08-16 10:19:39.266509+0800 XKHttpNetworkHelper[1243:103203] 任務3執行緒: <NSThread: 0x6000016fbc00>{number = 4,name = (null)}
2019-08-16 10:19:41.271556+0800 XKHttpNetworkHelper[1243:103203] 任務3執行緒: <NSThread: 0x6000016fbc00>{number = 4,name = (null)}
2019-08-16 10:19:41.271556+0800 XKHttpNetworkHelper[1243:103201] 任務4執行緒: <NSThread: 0x6000016c0080>{number = 3,name = (null)}
複製程式碼從執行任務的輸出日誌中可以看到:
1. 在執行完柵欄前面的操作之後，才執行柵欄操作，最後再執行柵欄後邊的操作。
複製程式碼6.2 延時方法: dispatch_after
在一些日常的開發任務中，會遇到這樣的需求: 在指定時間(例如3秒)之後執行某個任務。 可以用 dispatch_after 函式來實現。需要注意的是：
dispatch_after 函式並不是在指定時間之後才開始執行處理，而是在指定時間之後將任務追加到主佇列中。
嚴格來說，這個時間並不是絕對準確的，但想要大致延遲執行任務，dispatch_after函式是很有效的
複製程式碼/**
* 延時執行方法 dispatch_after
*/
- (void)afterTask {
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"afterTask : begin");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW,(int64_t)(2.0 * NSEC_PER_SEC)),dispatch_get_main_queue(),^{
// 2.0秒後非同步追加任務程式碼到主佇列，並開始執行
NSLog(@"延時任務: %@",[NSThread currentThread]); // 列印當前執行緒
});
NSLog(@"afterTask : end");
}
日誌輸出:
2019-08-16 10:32:09.909632+0800 XKHttpNetworkHelper[1406:131070] 當前執行緒 : <NSThread: 0x600003b32940>{number = 1,name = main}
2019-08-16 10:32:09.909756+0800 XKHttpNetworkHelper[1406:131070] afterTask : begin
2019-08-16 10:32:09.909846+0800 XKHttpNetworkHelper[1406:131070] afterTask : end
//間隔2後才打印
2019-08-16 10:32:12.105720+0800 XKHttpNetworkHelper[1406:131070] 延時任務: <NSThread: 0x600003b32940>{number = 1,name = main}
複製程式碼6.3 一次性程式碼（只執行一次）: dispatch_once
在實現單例建立或者整個程式執行過程只執行一次的程式碼時，就可以使用到 dispatch_once 函式。
使用 dispatch_once 函式能保證某段程式碼在程式執行過程中只被執行一次，並且即使多執行緒的環境下，dispatch_once 也可以保證執行緒安全
複製程式碼/**
* 一次性程式碼（只執行一次）dispatch_once
*/
- (void)onceTask{
static dispatch_once_t onceToken ;
dispatch_once(&onceToken,^{
// 只執行1次的程式碼(這裡面預設是執行緒安全的)
});
}
複製程式碼6.4 快速迭代方法: dispatch_apply
通常情況下，回使用for迴圈遍歷，但是GCD提供了快速迭代的方法 dispatch_apply
dispatch_apply按照指定的次數將指定的任務追加到指定的佇列中，並等待全部佇列執行結束。
複製程式碼還可以利用非同步佇列同時遍歷，例如： 遍歷0-5 這6個數字，for迴圈的做法是每次取出一個元素，逐個遍歷。而dispatch_apply 可以同時遍歷多個數字
/**
* 快速迭代方法 dispatch_apply
*/
- (void)applyTask{
NSLog(@"applyTask : begin");
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
dispatch_apply(6,queue,^(size_t index) {
NSLog(@"applyTask -- %ld: %@",index,[NSThread currentThread]); // 列印當前執行緒
});
NSLog(@"applyTask : end");
}
日誌輸出:
2019-08-16 14:09:49.328469+0800 XKHttpNetworkHelper[17064:389593] applyTask : begin
2019-08-16 14:09:49.328685+0800 XKHttpNetworkHelper[17064:389662] applyTask -- 1: <NSThread: 0x600001d9ca80>{number = 3,name = (null)}
2019-08-16 14:09:49.328702+0800 XKHttpNetworkHelper[17064:389593] applyTask -- 0: <NSThread: 0x600001ded480>{number = 1,name = main}
2019-08-16 14:09:49.328708+0800 XKHttpNetworkHelper[17064:389677] applyTask -- 5: <NSThread: 0x600001daa300>{number = 5,name = (null)}
2019-08-16 14:09:49.328711+0800 XKHttpNetworkHelper[17064:389675] applyTask -- 4: <NSThread: 0x600001db8100>{number = 4,name = (null)}
2019-08-16 14:09:49.328718+0800 XKHttpNetworkHelper[17064:389680] applyTask -- 3: <NSThread: 0x600001d83680>{number = 7,name = (null)}
2019-08-16 14:09:49.328723+0800 XKHttpNetworkHelper[17064:389676] applyTask -- 2: <NSThread: 0x600001db80c0>{number = 6,name = (null)}
2019-08-16 14:09:49.328862+0800 XKHttpNetworkHelper[17064:389593] applyTask : end
複製程式碼從執行任務的輸出日誌中可以看到:
1. 使用dispatch_apply遍歷的過程中，日誌輸出列印的結果順序不定，但 applyTask : end 是在最後才執行的
複製程式碼在併發佇列中非同步執行任務，所以各個任務的執行時間長短不定，所以結束的順序也不定，但是 applyTask : end一定在最後才執行，這是因為 dispatch_apply 函式會等待全部任務執行完畢
6.5 佇列組: dispatch_group
在日常開發過程中，可能回遇到類似於這樣的需求: 分別非同步執行2個耗時任務，然後當2個耗時任務都執行完畢後再回到主執行緒執行任務。比如“多工下載列表” ，對於這種情況的處理，我們可以使用 GCD的佇列組。
1. 呼叫佇列組的 dispatch_group_async 先把任務放到佇列中，然後將佇列放入佇列組中。或者使用佇列組的 dispatch_group_enter、dispatch_group_leave 組合 來實現
dispatch_group_async。
2. 呼叫佇列組的 dispatch_group_notify 回到指定執行緒執行任務。或者使用 dispatch_group_wait 回到當前執行緒繼續向下執行（會阻塞當前執行緒）。
複製程式碼6.5.1 dispatch_group_notify
監聽 group 中任務的完成狀態，當所有的任務都執行完成後，追加任務到 group 中，並執行任務。
複製程式碼/**
* 佇列組 dispatch_group_notify
*/
- (void)asyncGroupTask{
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"asyncGroupTask : begin");
dispatch_group_t group = dispatch_group_create();
//任務1
dispatch_group_async(group,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0),[NSThread currentThread]); // 列印當前執行緒
}
});
//任務2
dispatch_group_async(group,[NSThread currentThread]); // 列印當前執行緒
}
});
dispatch_group_notify(group,^{
// 等前面的非同步任務1、任務2都執行完畢後，回到主執行緒執行下邊任務
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"主執行緒: %@",[NSThread currentThread]); // 列印當前執行緒
}
NSLog(@"asyncGroupTask : end");
});
}
日誌輸出:
2019-08-16 14:24:29.498165+0800 XKHttpNetworkHelper[17285:415433] 當前執行緒 : <NSThread: 0x600003d8a940>{number = 1,name = main}
2019-08-16 14:24:29.498303+0800 XKHttpNetworkHelper[17285:415433] asyncGroupTask : begin
2019-08-16 14:24:31.500079+0800 XKHttpNetworkHelper[17285:415495] 任務1執行緒: <NSThread: 0x600003de1dc0>{number = 4,name = (null)}
2019-08-16 14:24:31.500080+0800 XKHttpNetworkHelper[17285:415502] 任務2執行緒: <NSThread: 0x600003dd4380>{number = 3,name = (null)}
2019-08-16 14:24:33.502466+0800 XKHttpNetworkHelper[17285:415495] 任務1執行緒: <NSThread: 0x600003de1dc0>{number = 4,name = (null)}
2019-08-16 14:24:33.502506+0800 XKHttpNetworkHelper[17285:415502] 任務2執行緒: <NSThread: 0x600003dd4380>{number = 3,name = (null)}
2019-08-16 14:24:35.502939+0800 XKHttpNetworkHelper[17285:415433] 主執行緒: <NSThread: 0x600003d8a940>{number = 1,name = main}
2019-08-16 14:24:37.503722+0800 XKHttpNetworkHelper[17285:415433] 主執行緒: <NSThread: 0x600003d8a940>{number = 1,name = main}
2019-08-16 14:24:37.503999+0800 XKHttpNetworkHelper[17285:415433] asyncGroupTask : end
複製程式碼從執行任務的輸出日誌中可以看到:
當所有任務都執行完成之後，才執行dispatch_group_notify block 中的任務。
複製程式碼6.5.2 dispatch_group_wait
暫停當前執行緒（阻塞當前執行緒），等待指定的 group 中的任務執行完成後，才會往下繼續執行。
複製程式碼/**
* 佇列組 dispatch_group_wait
*/
- (void)asyncGroupWaitTask{
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"asyncGroupWaitTask : begin");
dispatch_group_t group = dispatch_group_create();
//任務1
dispatch_group_async(group,[NSThread currentThread]); // 列印當前執行緒
}
});
// 等待上面的任務全部完成後，會往下繼續執行（會阻塞當前執行緒）
dispatch_group_wait(group,DISPATCH_TIME_FOREVER);
NSLog(@"asyncGroupWaitTask : end");
}
日誌輸出:
2019-08-19 09:56:49.433832+0800 XKHttpNetworkHelper[1752:316226] 當前執行緒 : <NSThread: 0x600003c7e900>{number = 1,name = main}
2019-08-19 09:56:49.434004+0800 XKHttpNetworkHelper[1752:316226] asyncGroupWaitTask : begin
2019-08-19 09:56:51.437733+0800 XKHttpNetworkHelper[1752:316342] 任務2執行緒: <NSThread: 0x600003c26e40>{number = 4,name = (null)}
2019-08-19 09:56:51.437754+0800 XKHttpNetworkHelper[1752:316341] 任務1執行緒: <NSThread: 0x600003c20140>{number = 3,name = (null)}
2019-08-19 09:56:53.439997+0800 XKHttpNetworkHelper[1752:316341] 任務1執行緒: <NSThread: 0x600003c20140>{number = 3,name = (null)}
2019-08-19 09:56:53.440009+0800 XKHttpNetworkHelper[1752:316342] 任務2執行緒: <NSThread: 0x600003c26e40>{number = 4,name = (null)}
2019-08-19 09:56:53.440181+0800 XKHttpNetworkHelper[1752:316226] asyncGroupWaitTask : end
//去除dispatch_group_wait後的日誌:
2019-08-19 09:58:26.873803+0800 XKHttpNetworkHelper[1855:321884] 當前執行緒 : <NSThread: 0x600003fd97c0>{number = 1,name = main}
2019-08-19 09:58:26.873944+0800 XKHttpNetworkHelper[1855:321884] asyncGroupWaitTask : begin
2019-08-19 09:58:26.874078+0800 XKHttpNetworkHelper[1855:321884] asyncGroupWaitTask : end
2019-08-19 09:58:28.877712+0800 XKHttpNetworkHelper[1855:322057] 任務1執行緒: <NSThread: 0x600003fa55c0>{number = 3,name = (null)}
2019-08-19 09:58:28.877736+0800 XKHttpNetworkHelper[1855:322065] 任務2執行緒: <NSThread: 0x600003f82fc0>{number = 4,name = (null)}
2019-08-19 09:58:30.880441+0800 XKHttpNetworkHelper[1855:322065] 任務2執行緒: <NSThread: 0x600003f82fc0>{number = 4,name = (null)}
2019-08-19 09:58:30.880441+0800 XKHttpNetworkHelper[1855:322057] 任務1執行緒: <NSThread: 0x600003fa55c0>{number = 3,name = (null)}
複製程式碼從執行任務的輸出日誌中可以看到:
當所有任務執行完成之後，才執行 dispatch_group_wait 之後的操作。但是，使用dispatch_group_wait 會阻塞當前執行緒
複製程式碼6.5.3 dispatch_group_enter、dispatch_group_leave
1. dispatch_group_enter 標誌著一個任務追加到 group，執行一次，相當於 group 中未執行完畢任務數+1
2. dispatch_group_leave 標誌著一個任務離開了 group，執行一次，相當於 group 中未執行完畢任務數-1。
3. 當 group 中未執行完畢任務數為0的時候，才會使dispatch_group_wait解除阻塞，以及執行追加到dispatch_group_notify中的任務
複製程式碼/**
* 佇列組 dispatch_group_enter、dispatch_group_leave
*/
- (void)asyncGroupEnterAndLeaveTask{
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"asyncGroupEnterAndLeaveTask : begin");
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
//任務1
dispatch_group_enter(group);
dispatch_async(queue,[NSThread currentThread]); // 列印當前執行緒
}
dispatch_group_leave(group);
});
//任務2
dispatch_group_enter(group);
dispatch_async(queue,[NSThread currentThread]); // 列印當前執行緒
}
dispatch_group_leave(group);
});
dispatch_group_notify(group,[NSThread currentThread]); // 列印當前執行緒
}
NSLog(@"asyncGroupEnterAndLeaveTask : end");
});
}
//日誌輸出:
2019-08-19 10:43:30.184976+0800 XKHttpNetworkHelper[19410:485864] 當前執行緒 : <NSThread: 0x6000008fe3c0>{number = 1,name = main}
2019-08-19 10:43:30.185190+0800 XKHttpNetworkHelper[19410:485864] asyncGroupEnterAndLeaveTask : begin
2019-08-19 10:43:32.189332+0800 XKHttpNetworkHelper[19410:486006] 任務1執行緒: <NSThread: 0x600000885400>{number = 4,name = (null)}
2019-08-19 10:43:32.189332+0800 XKHttpNetworkHelper[19410:486008] 任務2執行緒: <NSThread: 0x600000888000>{number = 3,name = (null)}
2019-08-19 10:43:34.192766+0800 XKHttpNetworkHelper[19410:486008] 任務2執行緒: <NSThread: 0x600000888000>{number = 3,name = (null)}
2019-08-19 10:43:34.192766+0800 XKHttpNetworkHelper[19410:486006] 任務1執行緒: <NSThread: 0x600000885400>{number = 4,name = (null)}
2019-08-19 10:43:36.193189+0800 XKHttpNetworkHelper[19410:485864] 主執行緒: <NSThread: 0x6000008fe3c0>{number = 1,name = main}
2019-08-19 10:43:38.193421+0800 XKHttpNetworkHelper[19410:485864] 主執行緒: <NSThread: 0x6000008fe3c0>{number = 1,name = main}
2019-08-19 10:43:38.193560+0800 XKHttpNetworkHelper[19410:485864] asyncGroupEnterAndLeaveTask : end
複製程式碼從執行任務的輸出日誌中可以看到:
當所有任務執行完成之後，才執行 dispatch_group_notify 中的任務。這裡的dispatch_group_enter、dispatch_group_leave組合，其實等同於dispatch_group_async
複製程式碼6.6 訊號量: dispatch_semaphore
GCD 中的訊號量是指 Dispatch Semaphore ，是持有計數的訊號。 類似於一個高速路收費站的欄杆。可以通過時，開啟欄杆，不可以通過時，關閉欄杆。
在 Dispatch Semaphore 中，使用計數來完成這個功能，計數為0時等待，不可通過。計數為1或大於1時，計數減1且不等待，可通過。
Dispatch Semaphore 提供了三個函式:
1. dispatch_semaphore_create: 建立一個Semaphore並初始化訊號的總量
2. dispatch_semaphore_signal: 傳送一個訊號，讓訊號總量加1
3. dispatch_semaphore_wait: 可以使總訊號量減1，當訊號總量為0時，就會一直等待（阻塞所線上程），否則就可以正常執行。
複製程式碼注意:
訊號量的使用前提是：想清楚你需要處理哪個執行緒等待（阻塞），又要哪個執行緒繼續執行，然後使用訊號量。
複製程式碼Dispatch Semaphore 在實際開發中主要用於：
1. 保持執行緒同步，將非同步執行任務轉換為同步執行任務
2. 保證執行緒安全，為執行緒加鎖
複製程式碼6.6.1 Dispatch Semaphore 執行緒同步
在日常開發任務中，會有這樣的需求: 非同步執行耗時任務，並使用非同步執行的結果進行一些額外的操作。 換句話說，相當於將非同步執行任務轉換為同步執行任務。
比如說：AFNetworking 中 AFURLSessionManager.m 裡面的 tasksForKeyPath: 方法。 通過引入訊號量的方式，等待非同步執行任務結果，獲取到 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 實現執行緒同步，將非同步執行任務轉換為同步執行任務。
/**
* 訊號量 dispatch_semaphore
*/
- (void)asyncSemaphoreTask {
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"asyncSemaphoreTask : begin");
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
__block NSInteger number = 0;
dispatch_async(queue,[NSThread currentThread]); // 列印當前執行緒
}
number = 100;
dispatch_semaphore_signal(semaphore);
});
dispatch_semaphore_wait(semaphore,DISPATCH_TIME_FOREVER);
NSLog(@"asyncSemaphoreTask: end,number = %zd",number);
}
日誌輸出:
2019-08-19 11:20:40.118988+0800 XKHttpNetworkHelper[20027:564696] 當前執行緒 : <NSThread: 0x600001490cc0>{number = 1,name = main}
2019-08-19 11:20:40.119158+0800 XKHttpNetworkHelper[20027:564696] asyncSemaphoreTask : begin
2019-08-19 11:20:42.123825+0800 XKHttpNetworkHelper[20027:564811] 任務1執行緒: <NSThread: 0x6000014c2640>{number = 3,name = (null)}
2019-08-19 11:20:44.128749+0800 XKHttpNetworkHelper[20027:564811] 任務1執行緒: <NSThread: 0x6000014c2640>{number = 3,name = (null)}
2019-08-19 11:20:44.128909+0800 XKHttpNetworkHelper[20027:564696] asyncSemaphoreTask: end,number = 100
複製程式碼從執行任務的輸出日誌中可以看到:
1. semaphore---end 是在執行完 number = 100; 之後才打印的。而且輸出結果 number 為 100。 這是因為非同步執行不會做任何等待，可以繼續執行任務。
2.非同步執行將任務1追加到佇列之後，不做等待，接著執行dispatch_semaphore_wait方法。此時 semaphore == 0，當前執行緒進入等待狀態。
然後，非同步任務1開始執行。任務1執行到dispatch_semaphore_signal之後，總訊號量，此時 semaphore == 1，dispatch_semaphore_wait方法使總訊號量減1，
正在被阻塞的執行緒（主執行緒）恢復繼續執行。
3. 最後列印 asyncSemaphoreTask: end,number = 100。這樣就實現了執行緒同步，將非同步執行任務轉換為同步執行任務。
複製程式碼6.6.2 Dispatch Semaphore 執行緒安全和執行緒同步（為執行緒加鎖）
執行緒安全:
1. 如果你的程式碼所在的程序中有多個執行緒在同時執行，而這些執行緒可能會同時執行這段程式碼。如果每次執行結果和單執行緒執行的結果是一樣的，而且其他的變數的值也和預期的是一樣的，就是執行緒安全的。
2. 若每個執行緒中對全域性變數、靜態變數只有讀操作，而無寫操作，一般來說，這個全域性變數是執行緒安全的；若有多個執行緒同時執行寫操作（更改變數），一般都需要考慮執行緒同步，否則的話就可能影響執行緒安全。
複製程式碼執行緒同步:
可理解為執行緒 A 和 執行緒 B 一塊配合，A 執行到一定程度時要依靠執行緒 B 的某個結果，於是停下來，示意 B 執行；B 依言執行，再將結果給 A；A 再繼續操作。
舉個簡單例子就是：兩個人在一起聊天。兩個人不能同時說話，避免聽不清(操作衝突)。等一個人說完(一個執行緒結束操作)，另一個再說(另一個執行緒再開始操作)。
複製程式碼場景模擬:
模擬火車票售賣的方式，實現 NSThread 執行緒安全和解決執行緒同步問題
需求：總共有50張火車票，有兩個售賣火車票的視窗，一個是北京火車票售賣視窗，另一個是上海火車票售賣視窗。兩個視窗同時售賣火車票，賣完為止。
複製程式碼6.6.2.1 非執行緒安全（不使用 semaphore）
/**
* 非執行緒安全：不使用 semaphore
* 初始化火車票數量、賣票視窗(非執行緒安全)、並開始賣票
*/
- (void)initTicketStatusNotSafeTask{
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"initTicketStatusNotSafeTask : begin");
self.ticketSurplusCount = 10;
// queue1 代表北京火車票售賣視窗
dispatch_queue_t queue1 = dispatch_queue_create("net.gcd.testQueue1",DISPATCH_QUEUE_SERIAL);
// queue2 代表上海火車票售賣視窗
dispatch_queue_t queue2 = dispatch_queue_create("net.gcd.testQueue2",DISPATCH_QUEUE_SERIAL);
__weak typeof(self) ws = self;
dispatch_async(queue1,^{
[ws saleTicketNotSafeTask];
});
dispatch_async(queue2,^{
[ws saleTicketNotSafeTask];
});
}
/**
* 售賣火車票(非執行緒安全)
*/
- (void)saleTicketNotSafeTask {
while (1) {
if (self.ticketSurplusCount > 0) { //如果還有票，繼續售賣
self.ticketSurplusCount--;
NSLog(@"%@",[NSString stringWithFormat:@"剩餘票數：%ld 視窗：%@",self.ticketSurplusCount,[NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
}else{ //如果已賣完，關閉售票視窗
NSLog(@"所有火車票均已售完");
break;
}
}
}
日誌輸出:
2019-08-19 11:53:16.220078+0800 XKHttpNetworkHelper[20418:614512] 當前執行緒 : <NSThread: 0x600002caa940>{number = 1,name = main}
2019-08-19 11:53:16.220223+0800 XKHttpNetworkHelper[20418:614512] initTicketStatusNotSafeTask : begin
2019-08-19 11:53:16.220462+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：8 視窗：<NSThread: 0x600002cf50c0>{number = 4,name = (null)}
2019-08-19 11:53:16.220498+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：9 視窗：<NSThread: 0x600002cc3d40>{number = 3,name = (null)}
2019-08-19 11:53:16.423119+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：6 視窗：<NSThread: 0x600002cf50c0>{number = 4,name = (null)}
2019-08-19 11:53:16.423124+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：7 視窗：<NSThread: 0x600002cc3d40>{number = 3,name = (null)}
2019-08-19 11:53:16.627985+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：4 視窗：<NSThread: 0x600002cc3d40>{number = 3,name = (null)}
2019-08-19 11:53:16.627986+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：5 視窗：<NSThread: 0x600002cf50c0>{number = 4,name = (null)}
2019-08-19 11:53:16.828705+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：3 視窗：<NSThread: 0x600002cf50c0>{number = 4,name = (null)}
2019-08-19 11:53:16.828705+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：2 視窗：<NSThread: 0x600002cc3d40>{number = 3,name = (null)}
2019-08-19 11:53:17.030931+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：1 視窗：<NSThread: 0x600002cf50c0>{number = 4,name = (null)}
2019-08-19 11:53:17.030943+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：1 視窗：<NSThread: 0x600002cc3d40>{number = 3,name = (null)}
2019-08-19 11:53:17.232633+0800 XKHttpNetworkHelper[20418:614556] 剩餘票數：0 視窗：<NSThread: 0x600002cf50c0>{number = 4,name = (null)}
2019-08-19 11:53:17.232645+0800 XKHttpNetworkHelper[20418:614561] 剩餘票數：0 視窗：<NSThread: 0x600002cc3d40>{number = 3,name = (null)}
2019-08-19 11:53:17.434801+0800 XKHttpNetworkHelper[20418:614556] 所有火車票均已售完
2019-08-19 11:53:17.434811+0800 XKHttpNetworkHelper[20418:614561] 所有火車票均已售完
複製程式碼從執行任務的輸出日誌中可以看到:
在不考慮執行緒安全，不使用 semaphore 的情況下，得到票數是錯亂的，這樣顯然不符合我們的需求，所以我們需要考慮執行緒安全問題。
複製程式碼6.6.2.2 執行緒安全（使用 semaphore 加鎖）
/**
* 執行緒安全：使用 semaphore 加鎖
* 初始化火車票數量、賣票視窗(執行緒安全)、並開始賣票
*/
- (void)initTicketStatusSafeTask{
NSLog(@"當前執行緒 : %@",[NSThread currentThread]);
NSLog(@"initTicketStatusNotSafeTask : begin");
self.semaphoreLock = dispatch_semaphore_create(1);
self.ticketSurplusCount = 10;
// queue1 代表北京火車票售賣視窗
dispatch_queue_t queue1 = dispatch_queue_create("net.gcd.testQueue1",^{
[ws saleTicketSafeTask];
});
dispatch_async(queue2,^{
[ws saleTicketSafeTask];
});
}
/**
* 售賣火車票(執行緒安全)
*/
- (void)saleTicketSafeTask {
while (1) {
// 相當於加鎖
dispatch_semaphore_wait(self.semaphoreLock,DISPATCH_TIME_FOREVER);
if (self.ticketSurplusCount > 0) { //如果還有票，繼續售賣
self.ticketSurplusCount--;
NSLog(@"%@",[NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
}else{ //如果已賣完，關閉售票視窗
NSLog(@"所有火車票均已售完");
// 相當於解鎖
dispatch_semaphore_signal(self.semaphoreLock);
break;
}
// 相當於解鎖
dispatch_semaphore_signal(self.semaphoreLock);
}
}
日誌輸出:
2019-08-19 12:02:25.846200+0800 XKHttpNetworkHelper[20593:640200] 當前執行緒 : <NSThread: 0x600003ed2900>{number = 1,name = main}
2019-08-19 12:02:25.846374+0800 XKHttpNetworkHelper[20593:640200] initTicketStatusNotSafeTask : begin
2019-08-19 12:02:25.846739+0800 XKHttpNetworkHelper[20593:640300] 剩餘票數：9 視窗：<NSThread: 0x600003e8c700>{number = 3,name = (null)}
2019-08-19 12:02:26.051095+0800 XKHttpNetworkHelper[20593:640302] 剩餘票數：8 視窗：<NSThread: 0x600003ede500>{number = 4,name = (null)}
2019-08-19 12:02:26.256409+0800 XKHttpNetworkHelper[20593:640300] 剩餘票數：7 視窗：<NSThread: 0x600003e8c700>{number = 3,name = (null)}
2019-08-19 12:02:26.459732+0800 XKHttpNetworkHelper[20593:640302] 剩餘票數：6 視窗：<NSThread: 0x600003ede500>{number = 4,name = (null)}
2019-08-19 12:02:26.664534+0800 XKHttpNetworkHelper[20593:640300] 剩餘票數：5 視窗：<NSThread: 0x600003e8c700>{number = 3,name = (null)}
2019-08-19 12:02:26.869298+0800 XKHttpNetworkHelper[20593:640302] 剩餘票數：4 視窗：<NSThread: 0x600003ede500>{number = 4,name = (null)}
2019-08-19 12:02:27.073980+0800 XKHttpNetworkHelper[20593:640300] 剩餘票數：3 視窗：<NSThread: 0x600003e8c700>{number = 3,name = (null)}
2019-08-19 12:02:27.278409+0800 XKHttpNetworkHelper[20593:640302] 剩餘票數：2 視窗：<NSThread: 0x600003ede500>{number = 4,name = (null)}
2019-08-19 12:02:27.480733+0800 XKHttpNetworkHelper[20593:640300] 剩餘票數：1 視窗：<NSThread: 0x600003e8c700>{number = 3,name = (null)}
2019-08-19 12:02:27.683954+0800 XKHttpNetworkHelper[20593:640302] 剩餘票數：0 視窗：<NSThread: 0x600003ede500>{number = 4,name = (null)}
2019-08-19 12:02:27.887163+0800 XKHttpNetworkHelper[20593:640300] 所有火車票均已售完
2019-08-19 12:02:27.887329+0800 XKHttpNetworkHelper[20593:640302] 所有火車票均已售完
複製程式碼從執行任務的輸出日誌中可以看到:
在考慮了執行緒安全的情況下，使用 dispatch_semaphore 機制之後，得到的票數是正確的，沒有出現混亂的情況。
複製程式碼