**
Grand Central Dispatch (GCD)
**是Apple開發的一個多核編程的較新的解決方法。它主要用於優化應用程序以支持多核處理器以及其餘對稱多處理系統。它是一個在線程池模式的基礎上執行的並行任務。git
GCD是一個替代諸如NSThread等技術的很高效和強大的技術。GCD徹底能夠處理諸如數據鎖定和資源泄漏等複雜的異步編程問題。GCD的工做原理是讓一個程序,根據可用的處理資源,安排他們在任何可用的處理器核心上平行排隊執行特定的任務。這個任務能夠是一個功能或者一個程序段。程序員
GCD兩個核心:任務、隊列github
任務:執行操做的意思,換句話說就是你在線程中執行的那段代碼。在 GCD 中是放在 block中的。執行任務有兩種方式:同步執行和異步執行。二者的主要區別是:是否等待隊列的任務執行結束,以及是否具有開啓新線程的能力。編程
備註:異步執行雖然具備開啓新線程的能力,可是並不必定開啓新線程。這跟任務所指定的隊列類型有關數組
隊列:這裏的隊列指執行任務的等待隊列,即用來存聽任務的隊列。隊列是一種特殊的線性表,採用 FIFO(先進先出)的原則,即新任務老是被插入到隊列的末尾,而讀取任務的時候老是從隊列的頭部開始讀取。每讀取一個任務,則從隊列中釋放一個任務 -> 串行隊列(Serial Dispatch Queue):每次只有一個任務被執行,讓任務一個接着一個地執行安全
備註:併發隊列的併發功能只有在異步函數下才有效markdown
dispatch_queue_create
來建立隊列,須要傳入兩個參數,第一個參數表示隊列的惟一標識符,用於 DEBUG,可爲空,Dispatch Queue 的名稱推薦使用應用程序 ID 這種逆序全程域名;第二個參數用來識別是串行隊列仍是併發隊列。
// 串行隊列的建立方法
dispatch_queue_t queue = dispatch_queue_create("com.yangkejun.GCDdemo", DISPATCH_QUEUE_SERIAL);
// 併發隊列的建立方法
dispatch_queue_t queue = dispatch_queue_create("com.yangkejun.GCDdemo", DISPATCH_QUEUE_CONCURRENT);
複製代碼
可以使用dispatch_get_main_queue()得到主隊列。多線程
// 主隊列的獲取方法
dispatch_queue_t queue = dispatch_get_main_queue();
複製代碼
// 全局併發隊列的獲取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
複製代碼
dispatch_sync
和異步執行任務建立方法dispatch_async
// 同步執行任務建立方法
dispatch_sync(queue, ^{
// 這裏放同步執行任務代碼
});
// 異步執行任務建立方法
dispatch_async(queue, ^{
// 這裏放異步執行任務代碼
});
複製代碼
雖然使用 GCD 只需兩步,可是既然咱們有兩種隊列(串行隊列/併發隊列),兩種任務執行方式(同步執行/異步執行),那麼咱們就有了四種不一樣的組合方式。
這四種不一樣的組合方式是:併發
- 同步執行 + 併發隊列
- 異步執行 + 併發隊列
- 同步執行 + 串行隊列
- 異步執行 + 串行隊列
實際上,剛纔還說了兩種特殊隊列:全局併發隊列、主隊列。全局併發隊列能夠做爲普通併發隊列來使用。可是主隊列由於有點特殊,因此咱們就又多了兩種組合方式。
這樣就有六種不一樣的組合方式:app
- 同步執行 + 主隊列
- 異步執行 + 主隊列
那麼這幾種不一樣組合方式各有什麼區別呢,這裏爲了方便,先上結果,再來說解。你能夠直接查看錶格結果
區別 | 併發隊列 | 串行隊列 | 主隊列 |
---|---|---|---|
同步 | 沒有開啓新線程,串行執行任務 | 沒有開啓新線程,串行執行任務 | 在同一個串行隊列中對當前隊列sync操做都會致使死鎖 |
異步 | 有開啓新線程,併發執行任務 | 有開啓新線程,串行執行任務 | 若是在當前隊列async,並不會開啓新線程;在其餘隊列當中再對該串行隊列進行asyn操做會開啓新線程 |
/**
* 同步執行 + 併發隊列
* 特色:在當前線程中執行任務,不會開啓新線程,執行完一個任務,再執行下一個任務。
*/
- (void)syncConcurrent{
NSLog(@"syncConcurrent---begin");
dispatch_queue_t queue = dispatch_queue_create("com.yangkejun.GCDdemo", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
// 追加任務1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"任務1");
}
});
dispatch_sync(queue, ^{
// 追加任務2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"任務2");
}
});
dispatch_sync(queue, ^{
// 追加任務3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"任務3");
}
});
NSLog(@"syncConcurrent---end");
}
複製代碼
2018-09-01 11:20:35.990306+0800 GCDdemo[7623:1164967] syncConcurrent---begin
2018-09-01 11:20:37.991056+0800 GCDdemo[7623:1164967] 任務1
2018-09-01 11:20:39.992478+0800 GCDdemo[7623:1164967] 任務1
2018-09-01 11:20:41.992903+0800 GCDdemo[7623:1164967] 任務2
2018-09-01 11:20:43.994114+0800 GCDdemo[7623:1164967] 任務2
2018-09-01 11:20:45.995727+0800 GCDdemo[7623:1164967] 任務3
2018-09-01 11:20:47.997277+0800 GCDdemo[7623:1164967] 任務3
2018-09-01 11:20:47.997598+0800 GCDdemo[7623:1164967] syncConcurrent---end
複製代碼
從同步執行 + 併發隊列中可看到:
/**
* 異步執行 + 併發隊列
* 特色:能夠開啓多個線程,任務交替(同時)執行。
*/
- (void)asyncConcurrent {
NSLog(@"asyncConcurrent---begin");
dispatch_queue_t queue = dispatch_queue_create("com.yangkejun.GCDdemo", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任務1
for (int i = 0; i < 2; ++i) {
NSLog(@"任務1");
}
});
dispatch_async(queue, ^{
// 追加任務2
for (int i = 0; i < 2; ++i) {
NSLog(@"任務2");
}
});
dispatch_async(queue, ^{
// 追加任務3
for (int i = 0; i < 3; ++i) {
NSLog(@"任務3");
}
});
NSLog(@"asyncConcurrent---end");
}
複製代碼
2018-09-01 11:24:11.550873+0800 GCDdemo[7663:1170782] asyncConcurrent---begin
2018-09-01 11:24:11.551104+0800 GCDdemo[7663:1170782] asyncConcurrent---end
2018-09-01 11:24:13.555075+0800 GCDdemo[7663:1170830] 任務3
2018-09-01 11:24:13.555094+0800 GCDdemo[7663:1170828] 任務2
2018-09-01 11:24:13.555136+0800 GCDdemo[7663:1170829] 任務1
2018-09-01 11:24:15.556107+0800 GCDdemo[7663:1170828] 任務2
2018-09-01 11:24:15.556107+0800 GCDdemo[7663:1170830] 任務3
2018-09-01 11:24:15.556169+0800 GCDdemo[7663:1170829] 任務1
複製代碼
在異步執行 + 併發隊列中能夠看出:
syncConcurrent---begin
和syncConcurrent---end
以後才執行的。說明當前線程沒有等待,而是直接開啓了新線程,在新線程中執行任務(異步執行不作等待,能夠繼續執行任務)/**
* 同步執行 + 串行隊列
* 特色:不會開啓新線程,在當前線程執行任務。任務是串行的,執行完一個任務,再執行下一個任務。
*/
- (void)syncSerial {
NSLog(@"syncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("com.yangkejun.GCDdemo", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
// 追加任務1
for (int i = 0; i < 2; ++i) {
NSLog(@"任務1");
}
});
dispatch_sync(queue, ^{
// 追加任務2
for (int i = 0; i < 2; ++i) {
NSLog(@"任務2");
}
});
dispatch_sync(queue, ^{
// 追加任務3
for (int i = 0; i < 2; ++i) {
NSLog(@"任務3");
}
});
NSLog(@"syncSerial---end");
}
複製代碼
2018-09-01 11:32:21.317319+0800 GCDdemo[7812:1184572] syncSerial---begin
2018-09-01 11:32:21.317523+0800 GCDdemo[7812:1184572] 任務1
2018-09-01 11:32:21.317688+0800 GCDdemo[7812:1184572] 任務1
2018-09-01 11:32:21.317798+0800 GCDdemo[7812:1184572] 任務2
2018-09-01 11:32:21.318036+0800 GCDdemo[7812:1184572] 任務2
2018-09-01 11:32:21.318264+0800 GCDdemo[7812:1184572] 任務3
2018-09-01 11:32:21.318398+0800 GCDdemo[7812:1184572] 任務3
2018-09-01 11:32:21.318516+0800 GCDdemo[7812:1184572] syncSerial---end
複製代碼
在同步執行 + 串行隊列能夠看到:
syncConcurrent---begin
和syncConcurrent---end
之間執行(同步任務須要等待隊列的任務執行結束)。/**
* 異步執行 + 串行隊列
* 特色:會開啓新線程,可是由於任務是串行的,執行完一個任務,再執行下一個任務。
*/
- (void)asyncSerial {
NSLog(@"asyncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("com.yangkejun.GCDdemo", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
// 追加任務1
for (int i = 0; i < 2; ++i) {
NSLog(@"任務1");
}
});
dispatch_async(queue, ^{
// 追加任務2
for (int i = 0; i < 2; ++i) {
NSLog(@"任務2");
}
});
dispatch_async(queue, ^{
// 追加任務3
for (int i = 0; i < 3; ++i) {
NSLog(@"任務3");
}
});
NSLog(@"asyncSerial---end");
}
複製代碼
2018-09-01 11:34:28.644771+0800 GCDdemo[7841:1188565] asyncSerial---begin
2018-09-01 11:34:28.645016+0800 GCDdemo[7841:1188565] asyncSerial---end
2018-09-01 11:34:28.645055+0800 GCDdemo[7841:1188668] 任務1
2018-09-01 11:34:28.645245+0800 GCDdemo[7841:1188668] 任務1
2018-09-01 11:34:28.645368+0800 GCDdemo[7841:1188668] 任務2
2018-09-01 11:34:28.645497+0800 GCDdemo[7841:1188668] 任務2
2018-09-01 11:34:28.645632+0800 GCDdemo[7841:1188668] 任務3
2018-09-01 11:34:28.645937+0800 GCDdemo[7841:1188668] 任務3
2018-09-01 11:34:28.647228+0800 GCDdemo[7841:1188668] 任務3
複製代碼
在異步執行 + 串行隊列能夠看到:
syncConcurrent---begin
和syncConcurrent---end
以後纔開始執行的(異步執行不會作任何等待,能夠繼續執行任務)。同步執行 + 主隊列在不一樣線程中調用結果也是不同,在主線程中調用會出現死鎖,而在其餘線程中則不會
主隊列:GCD自帶的一種特殊的串行隊列
dispatch_get_main_queue()
得到主隊列/**
* 同步執行 + 主隊列
* 特色(主線程調用):互等卡主不執行。
* 特色(其餘線程調用):不會開啓新線程,執行完一個任務,再執行下一個任務。
*/
- (void)syncMain {
NSLog(@"syncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
// 追加任務1
for (int i = 0; i < 2; ++i) {
NSLog(@"任務1");
}
});
dispatch_sync(queue, ^{
// 追加任務2
for (int i = 0; i < 2; ++i) {
NSLog(@"任務2");
}
});
dispatch_sync(queue, ^{
// 追加任務3
for (int i = 0; i < 2; ++i) {
NSLog(@"任務3");
}
});
NSLog(@"syncMain---end");
}
複製代碼
在同步執行 + 主隊列能夠驚奇的發現:
控制檯打印:
2018-09-01 11:40:20.241566+0800 GCDdemo[7940:1198784] syncMain---begin
複製代碼
在主線程中使用同步執行 + 主隊列,追加到主線程的任務一、任務二、任務3都再也不執行了,並且syncMain---end也沒有打印,在XCode 9上還會報崩潰。這是爲何呢?
這是由於咱們在主線程中執行syncMain方法,至關於把syncMain任務放到了主線程的隊列中。而同步執行會等待當前隊列中的任務執行完畢,纔會接着執行。那麼當咱們把任務1追加到主隊列中,任務1就在等待主線程處理完syncMain任務。而syncMain任務須要等待任務1執行完畢,才能接着執行。
那麼,如今的狀況就是syncMain任務和任務1都在等對方執行完畢。這樣你們互相等待,因此就卡住了,因此咱們的任務執行不了,並且syncMain---end也沒有打印。
// 使用 NSThread 的 detachNewThreadSelector 方法會建立線程,並自動啓動線程執行selector 任務
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
複製代碼
控制檯打印
2018-09-01 11:45:42.849981+0800 GCDdemo[8014:1207496] syncMain---begin
2018-09-01 11:45:42.854214+0800 GCDdemo[8014:1207397] 任務1
2018-09-01 11:45:42.854358+0800 GCDdemo[8014:1207397] 任務1
2018-09-01 11:45:42.855129+0800 GCDdemo[8014:1207397] 任務2
2018-09-01 11:45:42.855585+0800 GCDdemo[8014:1207397] 任務2
2018-09-01 11:45:42.856397+0800 GCDdemo[8014:1207397] 任務3
2018-09-01 11:45:42.856550+0800 GCDdemo[8014:1207397] 任務3
2018-09-01 11:45:42.856742+0800 GCDdemo[8014:1207496] syncMain---end
複製代碼
在其餘線程中使用同步執行 + 主隊列可看到:
爲何如今就不會卡住了呢? 由於syncMain 任務放到了其餘線程裏,而任務一、任務二、任務3都在追加到主隊列中,這三個任務都會在主線程中執行。syncMain 任務在其餘線程中執行到追加任務1到主隊列中,由於主隊列如今沒有正在執行的任務,因此,會直接執行主隊列的任務1,等任務1執行完畢,再接着執行任務二、任務3。因此這裏不會卡住線程
/**
* 異步執行 + 主隊列
* 特色:只在主線程中執行任務,執行完一個任務,再執行下一個任務
*/
- (void)asyncMain {
NSLog(@"asyncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
// 追加任務1
for (int i = 0; i < 2; ++i) {
NSLog(@"任務1");
}
});
dispatch_async(queue, ^{
// 追加任務2
for (int i = 0; i < 2; ++i) {
NSLog(@"任務2");
}
});
dispatch_async(queue, ^{
// 追加任務3
for (int i = 0; i < 3; ++i) {
NSLog(@"任務3");
}
});
NSLog(@"asyncMain---end");
}
複製代碼
2018-09-01 11:50:00.355229+0800 GCDdemo[8072:1214346] asyncMain---begin
2018-09-01 11:50:00.355416+0800 GCDdemo[8072:1214346] asyncMain---end
2018-09-01 11:50:00.360197+0800 GCDdemo[8072:1214346] 任務1
2018-09-01 11:50:00.360337+0800 GCDdemo[8072:1214346] 任務1
2018-09-01 11:50:00.360526+0800 GCDdemo[8072:1214346] 任務2
2018-09-01 11:50:00.360687+0800 GCDdemo[8072:1214346] 任務2
2018-09-01 11:50:00.361041+0800 GCDdemo[8072:1214346] 任務3
2018-09-01 11:50:00.361327+0800 GCDdemo[8072:1214346] 任務3
2018-09-01 11:50:00.361527+0800 GCDdemo[8072:1214346] 任務3
複製代碼
在異步執行 + 主隊列能夠看到:
在iOS開發過程當中,咱們通常在主線程裏邊進行UI刷新,例如:點擊、滾動、拖拽等事件。咱們一般把一些耗時的操做放在其餘線程,好比說圖片下載、文件上傳等耗時操做。而當咱們有時候在其餘線程完成了耗時操做時,須要回到主線程,那麼就用到了線程之間的通信。
/**
* 線程間通訊
*/
- (void)communication {
// 獲取全局併發隊列
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 (int i = 0; i < 2; ++i) {
NSLog(@"異步追加任務");
}
// 回到主線程
dispatch_async(mainQueue, ^{
// 追加在主線程中執行的任務
NSLog(@"追加在主線程中執行的任務");
});
});
}
複製代碼
2018-09-01 11:52:14.446526+0800 GCDdemo[8102:1218564] 異步追加任務
2018-09-01 11:52:14.446704+0800 GCDdemo[8102:1218564] 異步追加任務
2018-09-01 11:52:14.450938+0800 GCDdemo[8102:1218530] 追加在主線程中執行的任務
複製代碼
dispatch_barrier_async
方法在兩個操做組間造成柵欄。dispatch_barrier_async
函數會等待前邊追加到併發隊列中的任務所有執行完畢以後,再將指定的任務追加到該異步隊列中。而後在dispatch_barrier_async函數追加的任務執行完畢以後,異步隊列才恢復爲通常動做,接着追加任務到該異步隊列並開始執行。
/**
* 柵欄方法 dispatch_barrier_async
*/
- (void)barrier{
dispatch_queue_t queue = dispatch_queue_create("com.yangkejun.GCDdemo", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任務1
for (int i = 0; i < 2; ++i) {
NSLog(@"任務1");
}
});
dispatch_async(queue, ^{
// 追加任務2
for (int i = 0; i < 3; ++i) {
NSLog(@"任務2");
}
});
dispatch_barrier_async(queue, ^{
// 追加任務 barrier
for (int i = 0; i < 2; ++i) {
NSLog(@"追加任務 barrier");
}
});
dispatch_async(queue, ^{
// 追加任務3
for (int i = 0; i < 3; ++i) {
NSLog(@"任務3");
}
});
dispatch_async(queue, ^{
// 追加任務4
for (int i = 0; i < 2; ++i) {
NSLog(@"任務4");
}
});
}
複製代碼
2018-09-01 11:56:55.999942+0800 GCDdemo[8164:1226338] 任務2
2018-09-01 11:56:55.999942+0800 GCDdemo[8164:1226341] 任務1
2018-09-01 11:56:56.000127+0800 GCDdemo[8164:1226341] 任務1
2018-09-01 11:56:56.000128+0800 GCDdemo[8164:1226338] 任務2
2018-09-01 11:56:56.002212+0800 GCDdemo[8164:1226338] 任務2
2018-09-01 11:56:56.002415+0800 GCDdemo[8164:1226338] 追加任務 barrier
2018-09-01 11:56:56.002527+0800 GCDdemo[8164:1226338] 追加任務 barrier
2018-09-01 11:56:56.004423+0800 GCDdemo[8164:1226338] 任務3
2018-09-01 11:56:56.004423+0800 GCDdemo[8164:1226341] 任務4
2018-09-01 11:56:56.007921+0800 GCDdemo[8164:1226338] 任務3
2018-09-01 11:56:56.007973+0800 GCDdemo[8164:1226341] 任務4
2018-09-01 11:56:56.008898+0800 GCDdemo[8164:1226338] 任務3
複製代碼
在dispatch_barrier_async執行結果中能夠看出:
須要注意的是:dispatch_after函數並非在指定時間以後纔開始執行處理,而是在指定時間以後將任務追加到主隊列中。嚴格來講,這個時間並非絕對準確的,但想要大體延遲執行任務,dispatch_after函數是頗有效的。
/**
* 延時執行方法 dispatch_after
*/
- (void)after{
NSLog(@"after-begin");
int64_t delayInSeconds = 5.0; // 延遲的時間
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 5.0秒後異步追加任務代碼到主隊列,並開始執行
NSLog(@"after-end");
});
}
複製代碼
從圖時間能夠看出:
dispatch_once
函數能保證某段代碼在程序運行過程當中只被執行1次,而且即便在多線程的環境下,dispatch_once也能夠保證線程安全。/**
* 一次性代碼(只執行一次)dispatch_once
*/
- (void)once {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只執行1次的代碼(這裏面默認是線程安全的)
});
}
複製代碼
若是是在串行隊列中使用 dispatch_apply,那麼就和 for 循環同樣,按順序同步執行。可這樣就體現不出快速迭代的意義了。 咱們能夠利用併發隊列進行異步執行。好比說遍歷 0~5 這6個數字,for 循環的作法是每次取出一個元素,逐個遍歷。dispatch_apply 能夠 在多個線程中同時(異步)遍歷多個數字。 還有一點,不管是在串行隊列,仍是異步隊列中,dispatch_apply 都會等待所有任務執行完畢,這點就像是同步操做,也像是隊列組中的 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);
});
NSLog(@"apply---end");
}
複製代碼
2018-09-01 12:04:06.176242+0800 GCDdemo[8269:1238786] apply---begin
2018-09-01 12:04:06.177222+0800 GCDdemo[8269:1238786] 0
2018-09-01 12:04:06.177222+0800 GCDdemo[8269:1238836] 1
2018-09-01 12:04:06.177237+0800 GCDdemo[8269:1238834] 2
2018-09-01 12:04:06.177257+0800 GCDdemo[8269:1238837] 3
2018-09-01 12:04:06.177384+0800 GCDdemo[8269:1238786] 5
2018-09-01 12:04:06.177384+0800 GCDdemo[8269:1238836] 4
2018-09-01 12:04:06.177673+0800 GCDdemo[8269:1238786] apply---end
複製代碼
由於是在併發隊列中異步執行任務,因此各個任務的執行時間長短不定,最後結束順序也不定。可是apply---end必定在最後執行。這是由於dispatch_apply函數會等待所有任務執行完畢
有時候咱們會有這樣的需求:分別異步執行2個耗時任務,而後當2個耗時任務都執行完畢後再回到主線程執行任務。這時候咱們能夠用到 GCD 的隊列組。
- 調用隊列組的 dispatch_group_async 先把任務放到隊列中,而後將隊列放入隊列組中。或者使用隊列組的 dispatch_group_enter、dispatch_group_leave 組合 來實現dispatch_group_async。
- 調用隊列組的 dispatch_group_notify 回到指定線程執行任務。或者使用 dispatch_group_wait 回到當前線程繼續向下執行(會阻塞當前線程)
/**
* 隊列組 dispatch_group_notify
*/
- (void)groupNotify{
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任務1
for (int i = 0; i < 2; ++i) {
NSLog(@"任務1");
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任務2
for (int i = 0; i < 3; ++i) {
NSLog(@"任務2");
}
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的異步任務一、任務2都執行完畢後,回到主線程執行下邊任務
for (int i = 0; i < 2; ++i) {
NSLog(@"等前面的異步任務一、任務2都執行完畢後,回到主線程執行下邊任務");
}
NSLog(@"group---end");
});
}
複製代碼
2018-09-01 12:06:47.296416+0800 GCDdemo[8327:1243795] group---begin
2018-09-01 12:06:47.296645+0800 GCDdemo[8327:1243901] 任務1
2018-09-01 12:06:47.296646+0800 GCDdemo[8327:1243902] 任務2
2018-09-01 12:06:47.296780+0800 GCDdemo[8327:1243901] 任務1
2018-09-01 12:06:47.296873+0800 GCDdemo[8327:1243902] 任務2
2018-09-01 12:06:47.297396+0800 GCDdemo[8327:1243902] 任務2
2018-09-01 12:06:47.301247+0800 GCDdemo[8327:1243795] 等前面的異步任務一、任務2都執行完畢後,回到主線程執行下邊任務
2018-09-01 12:06:47.301386+0800 GCDdemo[8327:1243795] 等前面的異步任務一、任務2都執行完畢後,回到主線程執行下邊任務
2018-09-01 12:06:47.301485+0800 GCDdemo[8327:1243795] group---end
複製代碼
從dispatch_group_notify相關代碼運行輸出結果能夠看出: 當全部任務都執行完成以後,才執行dispatch_group_notify block 中的任務。
/**
* 隊列組 dispatch_group_wait
*/
- (void)groupWait{
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任務1
for (int i = 0; i < 2; ++i) {
NSLog(@"任務1");
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任務2
for (int i = 0; i < 2; ++i) {
NSLog(@"任務2");
}
});
// 等待上面的任務所有完成後,會往下繼續執行(會阻塞當前線程)
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"group---end");
}
複製代碼
2018-09-01 12:09:25.744072+0800 GCDdemo[8366:1248429] group---begin
2018-09-01 12:09:25.744328+0800 GCDdemo[8366:1248479] 任務2
2018-09-01 12:09:25.744328+0800 GCDdemo[8366:1248481] 任務1
2018-09-01 12:09:25.744444+0800 GCDdemo[8366:1248479] 任務2
2018-09-01 12:09:25.744469+0800 GCDdemo[8366:1248481] 任務1
2018-09-01 12:09:25.744753+0800 GCDdemo[8366:1248429] group---end
複製代碼
從dispatch_group_wait相關代碼運行輸出結果能夠看出: 當全部任務執行完成以後,才執行 dispatch_group_wait 以後的操做。可是,使用dispatch_group_wait 會阻塞當前線程。
- dispatch_group_enter 標誌着一個任務追加到 group,執行一次,至關於 group 中未執行完畢任務數+1
- dispatch_group_leave 標誌着一個任務離開了 group,執行一次,至關於 group 中未執行完畢任務數-1。
- 當 group 中未執行完畢任務數爲0的時候,纔會使dispatch_group_wait解除阻塞,以及執行追加到dispatch_group_notify中的任務。
/**
* 隊列組 dispatch_group_wait
*/
- (void)groupWait{
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任務1
for (int i = 0; i < 2; ++i) {
NSLog(@"任務1");
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任務2
for (int i = 0; i < 2; ++i) {
NSLog(@"任務2");
}
});
// 等待上面的任務所有完成後,會往下繼續執行(會阻塞當前線程)
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"group---end");
}
/**
* 隊列組 dispatch_group_enter、dispatch_group_leave
*/
- (void)groupEnterAndLeave{
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
for (int i = 0; i < 2; ++i) {
NSLog(@"任務1");
}
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任務2
for (int i = 0; i < 2; ++i) {
NSLog(@"任務2");
}
dispatch_group_leave(group);
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的異步操做都執行完畢後,回到主線程.
for (int i = 0; i < 2; ++i) {
NSLog(@"等前面的異步操做都執行完畢後,回到主線程.");
}
NSLog(@"group---end");
});
}
複製代碼
2018-09-01 12:11:26.418948+0800 GCDdemo[8393:1252025] group---begin
2018-09-01 12:11:26.419198+0800 GCDdemo[8393:1252093] 任務2
2018-09-01 12:11:26.419202+0800 GCDdemo[8393:1252092] 任務1
2018-09-01 12:11:26.419366+0800 GCDdemo[8393:1252092] 任務1
2018-09-01 12:11:26.419432+0800 GCDdemo[8393:1252093] 任務2
2018-09-01 12:11:26.424470+0800 GCDdemo[8393:1252025] 等前面的異步操做都執行完畢後,回到主線程.
2018-09-01 12:11:26.424751+0800 GCDdemo[8393:1252025] 等前面的異步操做都執行完畢後,回到主線程.
2018-09-01 12:11:26.425571+0800 GCDdemo[8393:1252025] group---end
複製代碼
從dispatch_group_enter、dispatch_group_leave相關代碼運行結果中能夠看出:當全部任務執行完成以後,才執行 dispatch_group_notify 中的任務。這裏的dispatch_group_enter、dispatch_group_leave組合,其實等同於dispatch_group_async。
Dispatch Semaphore 提供了三個函數。
- dispatch_semaphore_create:建立一個Semaphore並初始化信號的總量
- dispatch_semaphore_signal:發送一個信號,讓信號總量加1
- dispatch_semaphore_wait:可使總信號量減1,當信號總量爲0時就會一直等待(阻塞所在線程),不然就能夠正常執行。
注意:信號量的使用前提是:想清楚你須要處理哪一個線程等待(阻塞),又要哪一個線程繼續執行,而後使用信號量。
Dispatch Semaphore 在實際開發中主要用於:
/**
* semaphore 線程同步
*/
- (void)semaphoreSync{
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
NSLog(@"任務1");
number = 10;
dispatch_semaphore_signal(semaphore);
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
NSLog(@"semaphore---end,number = %d",number);
}
複製代碼
2018-09-01 12:21:30.061743+0800 GCDdemo[8488:1267170] semaphore---begin
2018-09-01 12:21:30.061998+0800 GCDdemo[8488:1267223] 任務1
2018-09-01 12:21:30.062167+0800 GCDdemo[8488:1267170] semaphore---end,number = 10
複製代碼
從 Dispatch Semaphore 實現線程同步的代碼能夠看到: semaphore---end 是在執行完 number = 10; 以後纔打印的。並且輸出結果 number 爲 10。 這是由於異步執行不會作任何等待,能夠繼續執行任務。異步執行將任務1追加到隊列以後,不作等待,接着執行dispatch_semaphore_wait方法。此時 semaphore == 0,當前線程進入等待狀態。而後,異步任務1開始執行。任務1執行到dispatch_semaphore_signal以後,總信號量,此時 semaphore == 1,dispatch_semaphore_wait方法使總信號量減1,正在被阻塞的線程(主線程)恢復繼續執行。最後打印semaphore---end,number = 10。這樣就實現了線程同步,將異步執行任務轉換爲同步執行任務
若每一個線程中對全局變量、靜態變量只有讀操做,而無寫操做,通常來講,這個全局變量是線程安全的;如有多個線程同時執行寫操做(更改變量),通常都須要考慮線程同步,不然的話就可能影響線程安全。
舉個簡單例子就是:兩我的在一塊兒聊天。兩我的不能同時說話,避免聽不清(操做衝突)。等一我的說完(一個線程結束操做),另外一個再說(另外一個線程再開始操做)。
下面,咱們模擬火車票售賣的方式,實現 NSThread 線程安全和解決線程同步問題。
場景:總共有50張火車票,有兩個售賣火車票的窗口,一個是北京火車票售賣窗口,另外一個是上海火車票售賣窗口。兩個窗口同時售賣火車票,賣完爲止
考慮線程安全的代碼:
/**
* 線程安全:使用 semaphore 加鎖
* 初始化火車票數量、賣票窗口(線程安全)、並開始賣票
*/
- (void)initTicketStatusSave{
NSLog(@"semaphore---begin");
semaphoreLock = dispatch_semaphore_create(1);
ticketCount = 10;
// queue1 表明北京火車票售賣窗口
dispatch_queue_t queue1 = dispatch_queue_create("com.yangkejun.GCDdemo1", DISPATCH_QUEUE_SERIAL);
// queue2 表明上海火車票售賣窗口
dispatch_queue_t queue2 = dispatch_queue_create("com.yangkejun.GCDdemo2", 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 (ticketCount > 0) { //若是還有票,繼續售賣
ticketCount--;
NSLog(@"%@", [NSString stringWithFormat:@"剩餘票數:%d 窗口:%@", ticketCount, [NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
} else { //若是已賣完,關閉售票窗口
NSLog(@"全部火車票均已售完 窗口:%@",[NSThread currentThread]);
// 至關於解鎖
dispatch_semaphore_signal(semaphoreLock);
break;
}
// 至關於解鎖
dispatch_semaphore_signal(semaphoreLock);
}
}
複製代碼
控制檯打印
2018-09-01 12:56:00.372291+0800 GCDdemo[8931:1322530] semaphore---begin
2018-09-01 12:56:00.372646+0800 GCDdemo[8931:1322575] 剩餘票數:9 窗口:<NSThread: 0x6000004676c0>{number = 3, name = (null)}
2018-09-01 12:56:00.577730+0800 GCDdemo[8931:1322577] 剩餘票數:8 窗口:<NSThread: 0x604000261f40>{number = 4, name = (null)}
2018-09-01 12:56:00.780380+0800 GCDdemo[8931:1322575] 剩餘票數:7 窗口:<NSThread: 0x6000004676c0>{number = 3, name = (null)}
2018-09-01 12:56:00.984349+0800 GCDdemo[8931:1322577] 剩餘票數:6 窗口:<NSThread: 0x604000261f40>{number = 4, name = (null)}
2018-09-01 12:56:01.188601+0800 GCDdemo[8931:1322575] 剩餘票數:5 窗口:<NSThread: 0x6000004676c0>{number = 3, name = (null)}
2018-09-01 12:56:01.393087+0800 GCDdemo[8931:1322577] 剩餘票數:4 窗口:<NSThread: 0x604000261f40>{number = 4, name = (null)}
2018-09-01 12:56:01.598030+0800 GCDdemo[8931:1322575] 剩餘票數:3 窗口:<NSThread: 0x6000004676c0>{number = 3, name = (null)}
2018-09-01 12:56:01.803240+0800 GCDdemo[8931:1322577] 剩餘票數:2 窗口:<NSThread: 0x604000261f40>{number = 4, name = (null)}
2018-09-01 12:56:02.007515+0800 GCDdemo[8931:1322575] 剩餘票數:1 窗口:<NSThread: 0x6000004676c0>{number = 3, name = (null)}
2018-09-01 12:56:02.211508+0800 GCDdemo[8931:1322577] 剩餘票數:0 窗口:<NSThread: 0x604000261f40>{number = 4, name = (null)}
2018-09-01 12:56:02.416522+0800 GCDdemo[8931:1322575] 全部火車票均已售完 窗口:<NSThread: 0x6000004676c0>{number = 3, name = (null)}
2018-09-01 12:56:02.416968+0800 GCDdemo[8931:1322577] 全部火車票均已售完 窗口:<NSThread: 0x604000261f40>{number = 4, name = (null)}
複製代碼
能夠看出,在考慮了線程安全的狀況下,使用 dispatch_semaphore
機制以後,獲得的票數是正確的,沒有出現混亂的狀況。咱們也就解決了多個線程同步的問題。
dispatch_block_cancel
來取消須要注意必須用dispatch_block_create建立dispatch_block_t
未執行的能夠用此方法cancel掉,若已經執行則cancel不掉
dispatch_block_testcancel
方法已將之封裝成宏和簡單函數,方便使用
// 同步會阻塞主線程
#pragma mark ********** 11.線程 GCD *********
// 異步主線程
#define kGCD_MAIN_ASYNC(main_queue_block) dispatch_async(dispatch_get_main_queue(), main_queue_block)
// 異步子線程
#define kGCD_QUEUE_ASYNC(global_queue_block) dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), global_queue_block)
// 一次性執行
#define kGCD_ONCE_BLOCK(onceBlock) static dispatch_once_t onceToken; dispatch_once(&onceToken, onceBlock);
// 異步並行隊列
#define kGCD_GROUP_ASYNC(group_async_block,group_notify_block) \
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);\
dispatch_group_t group = dispatch_group_create();\
dispatch_group_async(group, queue, group_async_block);\
dispatch_group_notify(group, queue, ^{\
dispatch_async(dispatch_get_main_queue(), group_notify_block);\
})\
// 異步主線程執行,不強持有Self,kGCD_Async_MainQueue({ self.button.padding = 20;});
#define kGCD_Async_MainQueue(x) \
__weak typeof(self) weakSelf = self; \
dispatch_async(dispatch_get_main_queue(), ^{ \
typeof(weakSelf) self = weakSelf; \
{x} \
});
複製代碼
#pragma mark - GCD 線程處理
NS_INLINE dispatch_queue_t kGCD_queue(void) {
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
return queue;
}
/// 主線程
NS_INLINE void kGCD_main(dispatch_block_t block) {
dispatch_queue_t queue = dispatch_get_main_queue();
if (strcmp(dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL), dispatch_queue_get_label(queue)) == 0) {
block();
}else{
if ([[NSThread currentThread] isMainThread]) {
dispatch_async(queue, block);
}else{
dispatch_sync(queue, block);
}
}
}
/// 子線程
NS_INLINE void kGCD_async(dispatch_block_t block) {
dispatch_queue_t queue = kGCD_queue();
if (strcmp(dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL), dispatch_queue_get_label(queue)) == 0) {
block();
}else{
dispatch_async(queue, block);
}
}
/// 異步並行隊列,攜帶可變參數(須要nil結尾)
NS_INLINE void kGCD_group_notify(dispatch_block_t notify,dispatch_block_t block,...) {
dispatch_queue_t queue = kGCD_queue();
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, block);
va_list args;dispatch_block_t arg;
va_start(args, block);
while ((arg = va_arg(args, dispatch_block_t))) {
dispatch_group_async(group, queue, arg);
}
va_end(args);
dispatch_group_notify(group, queue, notify);
}
/// 柵欄
NS_INLINE dispatch_queue_t kGCD_barrier(dispatch_block_t block,dispatch_block_t barrier) {
dispatch_queue_t queue = kGCD_queue();
dispatch_async(queue, block);
dispatch_barrier_async(queue, ^{ dispatch_async(dispatch_get_main_queue(), barrier); });
return queue;
}
/// 一次性
NS_INLINE void kGCD_once(dispatch_block_t block) {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, block);
}
/// 延時執行
NS_INLINE void kGCD_after(int64_t delayInSeconds, dispatch_block_t block) {
dispatch_queue_t queue = kGCD_queue();
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(time, queue, block);
}
NS_INLINE void kGCD_after_main(int64_t delayInSeconds, dispatch_block_t block) {
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(time, dispatch_get_main_queue(), block);
}
/// 主線程當中延時執行
NS_INLINE void kGCD_main_after(int64_t delayInSeconds, dispatch_block_t block) {
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(time, dispatch_get_main_queue(), block);
}
/// 快速迭代
NS_INLINE void kGCD_apply(int iterations, void(^block)(size_t idx)) {
dispatch_queue_t queue = kGCD_queue();
dispatch_apply(iterations, queue, block);
}
/// 快速遍歷數組
NS_INLINE void kGCD_apply_array(NSArray * temp, void(^block)(id obj, size_t index)) {
void (^xxblock)(size_t) = ^(size_t index){
block(temp[index],index);
};
dispatch_apply(temp.count, kGCD_queue(), xxblock);
}
/// 計時器
static dispatch_source_t gcd_timer = nil;
NS_INLINE dispatch_source_t kGCD_timer(int64_t delayInSeconds, dispatch_block_t block) {
if (gcd_timer) dispatch_source_cancel(gcd_timer);
dispatch_queue_t queue = kGCD_queue();
gcd_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
dispatch_source_set_timer(gcd_timer, dispatch_walltime(nil, 0), delayInSeconds * NSEC_PER_SEC, 0);
dispatch_source_set_event_handler(gcd_timer, block);
dispatch_resume(gcd_timer);
return gcd_timer;
}
複製代碼
pod 'KJEmitterView'
引入便可