本文是由于筆者在閱讀有關多線程的文章的時候,看到的覺得寫的很好, 就此記錄下.
在開發 APP 的時候很多時候可能會用到多線程, 就個人而言我是比較喜歡使用 GCD 的
那么使用 GCD 有什么好處呢?
1.GCD 可用于多核的并行運算
2.GCD 會自動利用更多的 CPU 內核（比如雙核、四核）
3.GCD 會自動管理線程的生命周期（創建線程、調度任務、銷毀線程）
4.程序員只需要告訴 GCD 想要執行什么任務，不需要編寫任何線程管理代碼
1.GCD的任務和隊列
學習 GCD 之前，先來了解 GCD 中兩個核心概念：任務和隊列。
任務：就是執行操作的意思，換句話說就是你在線程中執行的那段代碼。在 GCD 中是放在 block 中的。執行任務有兩種方式：同步執行（sync）和異步執行（async）。兩者的主要區別是：是否等待隊列的任務執行結束，以及是否具備開啟新線程的能力。
同步執行（sync）：
同步添加任務到指定的隊列中，在添加的任務執行結束之前，會一直等待，直到隊列里面的任務完成之后再繼續執行。
只能在當前線程中執行任務，特點是:不具備開啟新線程的能力。
異步執行（async）：
異步添加任務到指定的隊列中，它不會做任何等待，可以繼續執行任務。
可以在新的線程中執行任務，特點是:具備開啟新線程的能力。
注意：異步執行（async）雖然具有開啟新線程的能力，但是并不一定開啟新線程。這跟任務所指定的隊列類型有關（下面會講）。
隊列（Dispatch Queue）：這里的隊列指執行任務的等待隊列，即用來存放任務的隊列。隊列是一種特殊的線性表，采用 FIFO（先進先出）的原則，即新任務總是被插入到隊列的末尾，而讀取任務的時候總是從隊列的頭部開始讀取。每讀取一個任務，則從隊列中釋放一個任務。
在 GCD 中有兩種隊列：串行隊列和并發隊列。兩者都符合 FIFO（先進先出）的原則。兩者的主要區別是：執行順序不同，以及開啟線程數不同。
串行隊列（Serial Dispatch Queue）：
每次只有一個任務被執行。讓任務一個接著一個地執行。（只開啟一個線程，一個任務執行完畢后，再執行下一個任務）
并發隊列（Concurrent Dispatch Queue）：
可以讓多個任務并發（同時）執行。（可以開啟多個線程，并且同時執行任務）
注意：并發隊列的并發功能只有在異步（dispatch_async）函數下才有效
2 GCD 的使用步驟
1.創建一個隊列（串行隊列或并發隊列）
2將任務追加到任務的等待隊列中，然后系統就會根據任務類型執行任務（同步執行或異步執行）
2.1 隊列的創建方法/獲取方法
可以使用 dispatch_queue_create來 創建隊列，需要傳入兩個參數，第一個參數表示隊列的唯一標識符，用于 DEBUG，可為空，Dispatch Queue 的名稱推薦使用應用程序 ID 這種逆序全程域名；第二個參數用來識別是串行隊列還是并發隊列。DISPATCH_QUEUE_SERIAL 表示串行隊列，DISPATCH_QUEUE_CONCURRENT 表示并發隊列。
// 串行隊列的創建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
// 并發隊列的創建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
對于串行隊列，GCD 提供了的一種特殊的串行隊列： 主隊列（Main Dispatch Queue）.
特點 :所有放在主隊列中的任務，都會放到主線程中執行。
可使用dispatch_get_main_queue()獲得主隊列。
//獲取主隊列的方法
dispatch_queue_t queue = dispatch_get_main_queue()
對于并發隊列，GCD 默認提供了全局并發隊列（Global Dispatch Queue）。
可以使用dispatch_get_global_queue來獲取。需要傳入兩個參數。第一個參數表示隊列優先級，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數暫時沒用，用0即可。
//獲取全局并發隊列的獲取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
創建任務
GCD 提供了同步執行任務的創建方法dispatch_sync和異步執行任務創建方法dispatch_async。
//同步執行方法
dispatch_sync(queue, ^{
// 這里放同步執行任務代碼
});
//異步執行方法
dispatch_async(queue, ^{
// 這里放異步執行任務代碼
});
雖然使用 GCD 只需要兩步,但是我們知道有兩種隊列(串行隊列/并發隊列) 還有兩種執行方法(同步執行/異步執行)所以就有4中情況
1.同步執行 + 并發隊列
2.異步執行 + 并發隊列
3.同步執行 + 串行隊列
4.異步執行 + 串行隊列
上面也還提到了還存在一種主隊列那么還有下面兩種
5.同步執行 + 主隊列
那么他們的區別呢
6.異步執行 + 主隊列
60FF3328-8BB8-4E26-9720-F8DE0736015C.png
3.GCD 的基本使用
3.1 同步執行 + 并發隊列
特點是: 在當前線程中執行任務，不會開啟新線程，執行完一個任務，再執行下一個任務。
/*
同步執行 + 并發隊列
特點: 在當前線程中執行任務，不會開啟新線程，執行完一個任務，再執行下一個任務。
*/
-(void)syncConcurrent{
DLog(@"currentThread----%@",[NSThread currentThread]); //打印當前線程
DLog(@"syncConcurrent-------begin");
dispatch_queue_t queue = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
// 任務1
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"1----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_sync(queue, ^{
// 任務2
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"2----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_sync(queue, ^{
// 任務3
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"3----%@",[NSThread currentThread]); //打印當前線程
}
});
DLog(@"syncConcurrent-------end");
}
輸出結果
從上面的打印結果來看 所有的任務都是在主線程中執行的, 沒有開啟新的線程
任務按順序執行的。按順序執行的原因：雖然并發隊列可以開啟多個線程，并且同時執行多個任務。但是因為本身不能創建新線程，只有當前線程這一個線程（同步任務不具備開啟新線程的能力），所以也就不存在并發。而且當前線程只有等待當前隊列中正在執行的任務執行完畢之后，才能繼續接著執行下面的操作（同步任務需要等待隊列的任務執行結束）。所以任務只能一個接一個按順序執行，不能同時被執行。
3.2 異步執行 + 并發隊列
特點:可以開啟多個線程，任務交替（同時）執行。
/*
異步執行 + 并發隊列
特點:可以開啟多個線程，任務交替（同時）執行。
*/
-(void)asyncConcurrent{
DLog(@"currentThread----%@",[NSThread currentThread]); //打印當前線程
DLog(@"asyncConcurrent----begin");
dispatch_queue_t queue = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
//任務1
for (int i = 0 ; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"1-----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; i++) {
//任務2
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"2----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_async(queue, ^{
//任務3
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"3------%@",[NSThread currentThread]); //打印當前線程
}
});
DLog(@"asyncConcurrent----end");
}
打印效果如下
在異步執行 + 并發隊列中可以看出：
除了當前線程（主線程），系統又開啟了3個線程，并且任務是交替/同時執行的。（異步執行具備開啟新線程的能力。且并發隊列可開啟多個線程，同時執行多個任務）。
所有任務是在打印的asyncConcurrent---begin和asyncConcurrent---end之后才執行的。說明當前線程沒有等待，而是直接開啟了新線程，在新線程中執行任務（異步執行不做等待，可以繼續執行任務）。
3.3 同步執行 + 串行隊列
特點:不會開啟新的線程 在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務。
/*
同步執行 + 串行隊列
特點: 不會開啟新線程，在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務。
*/
-(void)syncSerial{
DLog(@"currentThread----%@",[NSThread currentThread]); //打印當前線程
DLog(@"syncSerial----begin");
dispatch_queue_t queue = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
//任務1
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"1-----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_sync(queue, ^{
//任務2
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"2-----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_sync(queue, ^{
//任務3
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"3-----%@",[NSThread currentThread]); //打印當前線程
}
});
DLog(@"syncSerial----end");
}
打印結果
從上面我們可以看出 所有任務都是在當前線程（主線程）中執行的，并沒有開啟新的線程（同步執行不具備開啟新線程的能力）。
任務是按順序執行的（串行隊列每次只有一個任務被執行，任務一個接一個按順序執行）。
3.4 異步執行 + 串行隊列
特點:會開啟新線程，但是因為任務是串行的，執行完一個任務，再執行下一個任務
/*
異步執行 + 串行隊列
特點: 會開啟新的線程 但是因為任務是串行的 執行完一個任務 在執行下一個
*/
-(void)asyncSerial{
DLog(@"currentThread----%@",[NSThread currentThread]); //打印當前線程
DLog(@"asyncSerial----begin");
dispatch_queue_t queue = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
//任務1
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"1-----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_async(queue, ^{
//任務2
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"2-----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_async(queue, ^{
//任務3
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"3-----%@",[NSThread currentThread]); //打印當前線程
}
});
DLog(@"asyncSerial----end");
}
在異步執行 + 串行隊列可以看到：
啟了一條新線程（異步執行具備開啟新線程的能力，串行隊列只開啟一個線程）。
所有任務是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執行的（異步執行不會做任何等待，可以繼續執行任務）。
任務是按順序執行的（串行隊列每次只有一個任務被執行，任務一個接一個按順序執行）。
下面說說主隊列:
主隊列是GCD自帶的一種特殊的串行隊列
所有放在主隊列中的任務，都會放到主線程中執行
可使用dispatch_get_main_queue()獲得主隊列
3.5同步執行 + 主隊列
在不同線程中調用結果也是不一樣，在主線程中調用會出現死鎖，而在其他線程中則不會。
3.5.1 在主線程中調用 同步執行 + 主隊列
互相等待卡住不可行
/*
同步執行 + 主隊列
特點(主線程調用): 互等卡主不執行, 都是大哥 互相禮讓就卡死了
特點(其他線程調用) : 不會開啟新線程 執行完一個任務 在執行下一個任務
*/
-(void)syncMain{
DLog(@"currentThread----%@",[NSThread currentThread]); //打印當前線程
DLog(@"syncMain----begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
//任務1
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"1--------%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_sync(queue, ^{
//任務2
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"2--------%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_sync(queue, ^{
//任務3
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"3--------%@",[NSThread currentThread]); //打印當前線程
}
});
DLog(@"syncMain----end");
}
在主線程調用主隊列 直接卡死
在主線程中使用同步執行 + 主隊列，追加到主線程的任務1、任務2、任務3都不再執行了，而且syncMain---end也沒有打印，在XCode 9上還會報崩潰。這是為什么呢？
這是因為我們在主線程中執行syncMain方法，相當于把syncMain任務放到了主線程的隊列中。而同步執行會等待當前隊列中的任務執行完畢，才會接著執行。那么當我們把任務1追加到主隊列中，任務1就在等待主線程處理完syncMain任務。而syncMain任務需要等待任務1執行完畢，才能接著執行。
那么，現在的情況就是syncMain任務和任務1都在等對方執行完畢。這樣大家互相等待，所以就卡住了，所以我們的任務執行不了，而且syncMain---end也沒有打印。
3.5.2 在其他線程中調用同步執行 + 主隊列
特點: 不會開啟新線程，執行完一個任務，再執行下一個任務
// 同步執行 + 主隊列(其他線程調用)
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
3.5.3 異步執行 + 主隊列
只在主線程中執行任務，執行完一個任務，再執行下一個任務。(即不會開啟新線程)
/*
異步執行 + 主隊列
特點: 只在主線程中執行任務 執行完一個任務, 在執行下一個任務
*/
-(void)asyncMain{
DLog(@"currentThread----%@",[NSThread currentThread]); //打印當前線程
DLog(@"asyncMain----begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
//任務1
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"1------%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_async(queue, ^{
//任務2
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"2------%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_async(queue, ^{
//任務3
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"3------%@",[NSThread currentThread]); //打印當前線程
}
});
DLog(@"asyncMain----end");
}
在異步執行 + 主隊列可以看到：
所有任務都是在當前線程（主線程）中執行的，并沒有開啟新的線程（雖然異步執行具備開啟線程的能力，但因為是主隊列，所以所有任務都在主線程中）。
所有任務是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執行的（異步執行不會做任何等待，可以繼續執行任務）。
任務是按順序執行的（因為主隊列是串行隊列，每次只有一個任務被執行，任務一個接一個按順序執行）。
綜上所述
同步執行 + 并發隊列
特點: 在當前線程中執行任務，不會開啟新線程，執行完一個任務，再執行下一個任務。
異步執行 + 并發隊列
特點:可以開啟多個線程，任務交替（同時）執行。
同步執行 + 串行隊列
特點: 不會開啟新線程，在當前線程執行任務。任務是串行的，執行完一個任務，再執行下一個任務。
異步執行 + 串行隊列
特點: 會開啟新的線程 但是因為任務是串行的 執行完一個任務 在執行下一個
同步執行 + 主隊列
特點(主線程調用): 互等卡主不執行, 都是大哥 互相禮讓就卡死了
特點(其他線程調用) : 不會開啟新線程 執行完一個任務 在執行下一個任務
異步執行 + 主隊列
特點: 只在主線程中執行任務 執行完一個人任務, 在執行下一個任務
除了 異步執行 + 并發隊列 里面的線程是可以交替執行的之外 其他的都是需要執行完一個任務，再執行下一個任務。
GCD 線程間的通信
在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++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"1-----%@",[NSThread currentThread]); //打印當前線程
}
//回到主線程
dispatch_async(mainQueue, ^{
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"2------%@",[NSThread currentThread]); //打印當前線程
});
});
}
可以看到在其他線程中先執行任務，執行完了之后回到主線程執行主線程的相應操作。
4. GCD 的其他方法
4.1 GCD 柵欄方法：dispatch_barrier_async
我們有時需要異步執行兩組操作，而且第一組操作執行完之后，才能開始執行第二組操作。這樣我們就需要一個相當于柵欄一樣的一個方法將兩組異步執行的操作組給分割起來，當然這里的操作組里可以包含一個或多個任務。這就需要用到dispatch_barrier_async方法在兩個操作組間形成柵欄。
dispatch_barrier_async函數會等待前邊追加到并發隊列中的任務全部執行完畢之后，再將指定的任務追加到該異步隊列中。然后在dispatch_barrier_async函數追加的任務執行完畢之后，異步隊列才恢復為一般動作，接著追加任務到該異步隊列并開始執行。
/*
柵欄方法 dispatch_barrier_async
特點 : 執行完前面的操作 在執行柵欄操作, 最后執行后面的(就像一個東西把他攔著一樣)
*/
-(void)barrier{
dispatch_queue_t queue = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_CONCURRENT);
//異步才能體現出來
dispatch_async(queue, ^{
for (int i = 0; i < 2; i++) {
//任務1
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"1-----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; i++) {
//任務2
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"2-----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_barrier_sync(queue, ^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2];
DLog(@"barrier------%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; i++) {
//任務3
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"3-----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; i++) {
//任務4
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"4-----%@",[NSThread currentThread]); //打印當前線程
}
});
}
在dispatch_barrier_async執行結果中可以看出：
在執行完柵欄前面的操作之后，才執行柵欄操作，最后再執行柵欄后邊的操作。
4.2 GCD 延時執行方法：dispatch_after
特點就是代碼延遲幾秒執行
/*
延時執行方法 dispatch_after
*/
-(void)after{
DLog(@"currentThread----%@",[NSThread currentThread]); //打印當前線程
DLog(@"after----begin");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
DLog(@"after-----%@",[NSThread currentThread]);
});
}
4.3GCD 一次性代碼（只執行一次）
我們在創建單例、或者有整個程序運行過程中只執行一次的代碼時，我們就用到了 GCD 的 dispatch_once 函數。使用dispatch_once 函數能保證某段代碼在程序運行過程中只被執行1次，并且即使在多線程的環境下，dispatch_once也可以保證線程安全。除了第一次調用的時候會執行, 之后在此調用變不在執行
/*
一次性代碼執行(只會執行一次) dispatch_once (可以使用單例)
*/
-(void)once{
static dispatch_once_t onceToken;
dispatch_once(&onceToken,^{
DLog(@"222222");
});
}
4.4 GCD 快速迭代方法：dispatch_apply
通常我們會用 for 循環遍歷，但是 GCD 給我們提供了快速迭代的函數dispatch_apply。dispatch_apply按照指定的次數將指定的任務追加到指定的隊列中，并等待全部隊列執行結束。
如果是在串行隊列中使用 dispatch_apply，那么就和 for 循環一樣，按順序同步執行。可這樣就體現不出快速迭代的意義了。
我們可以利用并發隊列進行異步執行。比如說遍歷 0~5 這6個數字，for 循環的做法是每次取出一個元素，逐個遍歷。dispatch_apply 可以 在多個線程中同時（異步）遍歷多個數字。
還有一點，無論是在串行隊列，還是異步隊列中，dispatch_apply 都會等待全部任務執行完畢，這點就像是同步操作，也像是隊列組中的 dispatch_group_wait方法。
/*
快速迭代方法 dispatch_apply (他的作用有點類似 for 循環) 在串行隊列中 在異步或者并發隊列中他的優勢更能提現出來
*/
-(void)apply{
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
DLog(@"apply-----begin");
dispatch_apply(6, queue, ^(size_t index) {
DLog(@"%ld-----%@",index,[NSThread currentThread]);
});
DLog(@"apply-----end");
}
因為是在并發隊列中異步執行任務，所以各個任務的執行時間長短不定，最后結束順序也不定。但是apply---end一定在最后執行。這是因為dispatch_apply函數會等待全部任務執行完畢
4.5 GCD 隊列組：dispatch_group
有時候我們會有這樣的需求：分別異步執行2個耗時任務，然后當2個耗時任務都執行完畢后再回到主線程執行任務。這時候我們可以用到 GCD 的隊列組。
調用隊列組的 dispatch_group_async 先把任務放到隊列中，然后將隊列放入隊列組中。或者使用隊列組的 dispatch_group_enter、dispatch_group_leave 組合 來實現dispatch_group_async。
調用隊列組的 dispatch_group_notify 回到指定線程執行任務。或者使用 dispatch_group_wait 回到當前線程繼續向下執行（會阻塞當前線程）。
4.5.1 dispatch_group_notify 不會阻塞當前線程
監聽 group 中任務的完成狀態，當所有的任務都執行完成后，追加任務到 group 中，并執行任務。
/*
隊列組 dispatch_group_notify
*/
-(void)groupNotify{
DLog(@"currentThread-----%@",[NSThread currentThread]); //打印當前線程
DLog(@"groupNotify----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++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"1-----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
//任務1
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"2-----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的異步任務1、任務2都執行完畢后，回到主線程執行下邊任務
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"3-----%@",[NSThread currentThread]); // 打印當前線程
}
DLog(@"group-----end");
});
}
從上面可以看出：
當所有任務都執行完成之后，才執行dispatch_group_notify block 中的任務。
4.5.2 dispatch_group_wait 會阻塞當前線程
特點:暫停當前線程（阻塞當前線程），等待指定的 group 中的任務執行完成后，才會往下繼續執行。 頁面會暫時卡住 等執行完上面的之后 就好了
/*
隊列組 dispatch_group_wait
特點:等待上面的任務全部完成后悔往下繼續執行 (其目的就是阻塞當前線程)
*/
-(void)groupWait{
DLog(@"currentThread-----%@",[NSThread currentThread]); //打印當前線程
DLog(@"groupWait----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++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"1-----%@",[NSThread currentThread]); //打印當前線程
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
//任務2
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"2-----%@",[NSThread currentThread]); //打印當前線程
}
});
//等待上面的任務全部完成后悔往下繼續執行 (其目的就是阻塞當前線程)
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
DLog(@"group-------end");
}
從上面可以看出:
當所有任務執行完成之后，才執行 dispatch_group_wait 之后的操作。但是，使用dispatch_group_wait 會阻塞當前線程。
4.5.3 dispatch_group_enter、dispatch_group_leave
dispatch_group_enter 標志著一個任務追加到 group，執行一次，相當于 group 中未執行完畢任務數+1
dispatch_group_leave 標志著一個任務離開了 group，執行一次，相當于 group 中未執行完畢任務數-1。
當 group 中未執行完畢任務數為0的時候，才會使dispatch_group_wait解除阻塞，以及執行追加到dispatch_group_notify中的任務。
/*
隊列組 dispatch_group_enter、dispatch_group_leave
*/
-(void)groupEnterAndLeave{
DLog(@"currentThread-----%@",[NSThread currentThread]); //打印當前線程
DLog(@"groupEnterAndLeave----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++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"1-----%@",[NSThread currentThread]); //打印當前線程
}
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_async(queue, ^{
//任務2
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
DLog(@"2-----%@",[NSThread currentThread]); //打印當前線程
}
dispatch_group_leave(group);
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
//等到前面的異步操作執行完之后 回到主線程
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印當前線程
}
NSLog(@"group---end");
});
}
從上面可以看出
當所有任務執行完成之后，才執行 dispatch_group_notify 中的任務。這里的dispatch_group_enter、dispatch_group_leave組合，其實等同于dispatch_group_async。
4.5.4 Dispatch Semaphore 線程同步
我們來利用 Dispatch Semaphore 實現線程同步，將異步執行任務轉換為同步執行任務。
/*
semaphore 線程同步
*/
-(void)semaphore{
DLog(@"currentThread-----%@",[NSThread currentThread]); //打印當前線程
DLog(@"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]; // 模擬耗時操作
DLog(@"1---------%@",[NSThread currentThread]); // 打印當前線程
number = 100;
dispatch_semaphore_signal(semaphore);
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
DLog(@"semaphore---end,number = %zd",number);
// semaphore---end,number = 100 打印的是這樣的, 說明是一起出來的
}
semaphore---end 是在執行完 number = 100; 之后才打印的。而且輸出結果 number 為 100。
這是因為異步執行不會做任何等待，可以繼續執行任務。異步執行將任務1追加到隊列之后，不做等待，接著執行dispatch_semaphore_wait方法。此時 semaphore == 0，當前線程進入等待狀態。然后，異步任務1開始執行。任務1執行到dispatch_semaphore_signal之后，總信號量，此時 semaphore == 1，dispatch_semaphore_wait方法使總信號量減1，正在被阻塞的線程（主線程）恢復繼續執行。最后打印semaphore---end,number = 100。這樣就實現了線程同步，將異步執行任務轉換為同步執行任務。
4.5.5Dispatch Semaphore 線程安全和線程同步（為線程加鎖）
線程安全：如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。
若每個線程中對全局變量、靜態變量只有讀操作，而無寫操作，一般來說，這個全局變量是線程安全的；若有多個線程同時執行寫操作（更改變量），一般都需要考慮線程同步，否則的話就可能影響線程安全。
線程同步：可理解為線程 A 和 線程 B 一塊配合，A 執行到一定程度時要依靠線程 B 的某個結果，于是停下來，示意 B 運行；B 依言執行，再將結果給 A；A 再繼續操作
下面，我們模擬火車票售賣的方式，實現 NSThread 線程安全和解決線程同步問題。
場景：總共有50張火車票，有兩個售賣火車票的窗口，一個是北京火車票售賣窗口，另一個是上海火車票售賣窗口。兩個窗口同時售賣火車票，賣完為止。
4.5.5.1 非線程安全（不使用 semaphore）
/*
非線程安全 不使用 semaphore
初始化火車票數量 賣票窗口(非線程安全) 并開始賣票
*/
-(void)initTicketStatusNotSave{
DLog(@"currentThread-----%@",[NSThread currentThread]); //打印當前線程
DLog(@"initTicketStatusNotSave----begin");
self.ticketSurplusCount = 50;
//queue1 代表窗口1售賣火車票
dispatch_queue_t queue1 = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
//queue2 代表窗口2 售賣火車票
dispatch_queue_t queue2 = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
@weakify(self)
dispatch_async(queue1, ^{
@strongify(self)
[self saleTicketNotSafe];
});
dispatch_async(queue2, ^{
@strongify(self)
[self saleTicketNotSafe];
});
}
/*
售賣火車票(非線程安全)
*/
-(void)saleTicketNotSafe{
while (true) {
if (self.ticketSurplusCount > 0) {
self.ticketSurplusCount -- ;
DLog(@"%@",[NSString stringWithFormat:@"剩余票數:%d 窗口:%@",self.ticketSurplusCount,[NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
}else{
DLog(@"所有火車票均已售完");
break;
}
}
}
可以看到在不考慮線程安全，不使用 semaphore 的情況下，得到票數是錯亂的，這樣顯然不符合我們的需求，所以我們需要考慮線程安全問題
4.5.5.2 線程安全（使用 semaphore 加鎖）
dispatch_semaphore_t semapgoreLock;
/*
線程安全:使用 samephore 加鎖
初始化火車票數量、賣票窗口(線程安全)、并開始賣票
*/
-(void)initTicketStatusSave{
DLog(@"currentThread-----%@",[NSThread currentThread]); //打印當前線程
DLog(@"initTicketStatusSave----begin");
self.ticketSurplusCount = 50;
semapgoreLock = dispatch_semaphore_create(1);
//queue1 代表窗口1售賣火車票
dispatch_queue_t queue1 = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
//queue2 代表窗口2 售賣火車票
dispatch_queue_t queue2 = dispatch_queue_create("com.wangyu.cn.YukiFramework", DISPATCH_QUEUE_SERIAL);
@weakify(self)
dispatch_async(queue1, ^{
@strongify(self)
[self saleTicketSafe];
});
dispatch_async(queue2, ^{
@strongify(self)
[self saleTicketSafe];
});
}
/*
售賣火車票(線程安全)
*/
-(void)saleTicketSafe{
while (1) {
//相等于加鎖
dispatch_semaphore_wait(semapgoreLock, DISPATCH_TIME_FOREVER);
if ( self.ticketSurplusCount > 0) { //如果有就繼續賣
self.ticketSurplusCount -- ;
DLog(@"%@",[NSString stringWithFormat:@"剩余票數:%d 窗口:%@",self.ticketSurplusCount,[NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
}else{
DLog(@"所有火車票賣完");
//相當于解鎖
dispatch_semaphore_signal(semapgoreLock);
break;
}
//相當于解鎖
dispatch_semaphore_signal(semapgoreLock);
}
}
可以看出，在考慮了線程安全的情況下，使用 dispatch_semaphore
機制之后，得到的票數是正確的，沒有出現混亂的情況。我們也就解決了多個線程同步的問題。
相關代碼已經傳到 GitHud 上Demo
本文摘自iOS多線程：『GCD』詳盡總結
