前面說了iOS使用多線程共有四種方式，Pthread和NSThread也已經(jīng)講過了，這一次主要學(xué)習(xí)Grand Central Dispatch，也就是GCD。
GCD的使用不需要我們自己管理生命周期，也就是不用我們再做創(chuàng)建線程，啟動線程等等這些繁瑣的操作，我們只需要三個步驟：
1、創(chuàng)建或者獲取隊列
2、創(chuàng)建任務(wù)
3、把任務(wù)加進(jìn)隊列
所以，我們要學(xué)會GCD就要搞懂兩個概念：隊列和任務(wù)。

隊列 百度百科這么定義的：隊列是一種特殊的線性表，特殊之處在于它只允許在表的前端（front）進(jìn)行刪除操作，而在表的后端（rear）進(jìn)行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進(jìn)行插入操作的端稱為隊尾，進(jìn)行刪除操作的端稱為隊頭。我們這里的隊列就是存放任務(wù)的線性表，有兩種形式：串行隊列 和 并行隊列
串行隊列 隊列中的任務(wù)一個接一個的執(zhí)行，主隊列也是一種特殊的串行隊列，主隊列是程序啟動就已經(jīng)創(chuàng)建好了的，所以我們?nèi)绻褂弥恍枰@取就可以了，主隊列中的任務(wù)都是在主線程中執(zhí)行的。
并行隊列 并行隊列的任務(wù)是一起執(zhí)行的(前提是任務(wù)能夠開辟新線程)，全局隊列就是一種特殊的并發(fā)隊列，也是系統(tǒng)幫我們創(chuàng)建好的，我們只需獲取就可以使用。

任務(wù) 其實就是你要執(zhí)行的代碼，任務(wù)也是有兩種形式：同步任務(wù) 和 異步任務(wù)
同步任務(wù) 不會開辟新線程，在當(dāng)前線程執(zhí)行。
異步任務(wù) 開辟新線程，在新線程中執(zhí)行。

從前面學(xué)習(xí)到的知識我們知道，隊列和任務(wù)是要配合使用的，所以，兩種隊列、兩種任務(wù)一共就是四種組合模式。
串行同步 當(dāng)前線程中一個接一個的執(zhí)行，如果是在主隊列中執(zhí)行同步任務(wù)，會造成死鎖，不是我們這章的重點，需要的請看我的理解。
串行異步 會開辟一條新線程，然后一個接一個的執(zhí)行。
并行同步 不會開辟新線程，一個接一個執(zhí)行。
并行異步 會開辟新線程，同時執(zhí)行。
總結(jié)，開辟不開辟新線程由任務(wù)決定，執(zhí)行順序共同決定，要同時執(zhí)行多個任務(wù)，只能并行異步。

說了很多了，是時候來點實際的
串行同步

- (void)serialSync {
    dispatch_queue_t dispatchQueue = dispatch_queue_create("serial", DISPATCH_QUEUE_SERIAL);//創(chuàng)建一個串行隊列
    dispatch_sync(dispatchQueue, ^(){
        [NSThread sleepForTimeInterval:1];//線程睡眠1秒
        NSLog(@"dispatch-serail-1----%@", [NSThread currentThread]);
    }); //添加一個同步任務(wù)
    dispatch_sync(dispatchQueue, ^(){
        [NSThread sleepForTimeInterval:2];
        NSLog(@"dispatch-serail-2---%@", [NSThread currentThread]);
    });
    dispatch_sync(dispatchQueue, ^(){
        [NSThread sleepForTimeInterval:3];
        NSLog(@"dispatch-serail-3---%@", [NSThread currentThread]);
    });
}

下面看一下打印結(jié)果

151503551729_.pic_hd.jpg

在主線程中執(zhí)行，并且時間間隔分別是2秒和3秒，看來我們前面的推斷沒有錯，串行同步不開辟新縣城并且順序執(zhí)行。

串行異步

- (void)serialAsync {
    NSLog(@"dispatch-serail-0----%@", [NSThread currentThread]);
    dispatch_queue_t dispatchQueue = dispatch_queue_create("serial", DISPATCH_QUEUE_SERIAL);//還是串行隊列
    dispatch_async(dispatchQueue, ^(){
        [NSThread sleepForTimeInterval:1];
        NSLog(@"dispatch-serail-1----%@", [NSThread currentThread]);
    });
    dispatch_async(dispatchQueue, ^(){
        [NSThread sleepForTimeInterval:2];
        NSLog(@"dispatch-serail-2---%@", [NSThread currentThread]);
    });
    dispatch_async(dispatchQueue, ^(){
        [NSThread sleepForTimeInterval:3];
        NSLog(@"dispatch-serail-3---%@", [NSThread currentThread]);
    });
}

看結(jié)果

161503553334_.pic_hd.jpg

串行異步開辟一條線程順序執(zhí)行。

并行同步

- (void)concurrentSync {
    dispatch_queue_t dispatchQueue = dispatch_queue_create("concurrent", DISPATCH_QUEUE_CONCURRENT);//創(chuàng)建并行隊列DISPATCH_QUEUE_CONCURRENT
    dispatch_sync(dispatchQueue, ^(){
        [NSThread sleepForTimeInterval:1];
        NSLog(@"dispatch-serail-1----%@", [NSThread currentThread]);
    });
    dispatch_sync(dispatchQueue, ^(){
        [NSThread sleepForTimeInterval:2];
        NSLog(@"dispatch-serail-2---%@", [NSThread currentThread]);
    });
    dispatch_sync(dispatchQueue, ^(){
        [NSThread sleepForTimeInterval:3];
        NSLog(@"dispatch-serail-3---%@", [NSThread currentThread]);
    });
}

結(jié)果

171503554226_.pic_hd.jpg

在主線程中順序執(zhí)行

并行異步

- (void)concurrentAsync {
    NSLog(@"dispatch-serail-0----%@", [NSThread currentThread]);
    dispatch_queue_t dispatchQueue2 = dispatch_queue_create("concurrent", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(dispatchQueue2, ^(){
        [NSThread sleepForTimeInterval:1];
        NSLog(@"dispatch-serail-1----%@", [NSThread currentThread]);
    });
    dispatch_async(dispatchQueue2, ^(){
        [NSThread sleepForTimeInterval:1];
        NSLog(@"dispatch-serail-2---%@", [NSThread currentThread]);
    });
    dispatch_async(dispatchQueue2, ^(){
        [NSThread sleepForTimeInterval:1];
        NSLog(@"dispatch-serail-3---%@", [NSThread currentThread]);
    });
}

看結(jié)果

看number表明它們都開辟了新線程，看時間是同時執(zhí)行的，看黃框表明它們順序是不定的。這就是真正意義上的異步執(zhí)行。

基本用法我們搞明白了，讓我們一起研究一下還有一些什么別的用法把。

- (void)apply {
    dispatch_queue_t dispatchQueue = dispatch_queue_create("", DISPATCH_QUEUE_CONCURRENT);
    dispatch_apply(3, dispatchQueue, ^(size_t t){
        [NSThread sleepForTimeInterval:1];
        NSLog(@"tttt : %zu" , t);
    });
}

2017-08-24 14:21:32.690 thread[54949:4940796] tttt : 0
2017-08-24 14:21:32.690 thread[54949:4940842] tttt : 2
2017-08-24 14:21:32.690 thread[54949:4940860] tttt : 1

任務(wù)迭代執(zhí)行，還是很有用的，比如說要對某個數(shù)組進(jìn)行無序遍歷，用任務(wù)迭代執(zhí)行還是比較快的。

看一下延時方法

NSLog(@"after-0----%@", [NSThread currentThread]);
    dispatch_queue_t dispatchQueue = dispatch_queue_create("", DISPATCH_QUEUE_CONCURRENT);
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatchQueue, ^{
        // 延時兩秒執(zhí)行
        NSLog(@"affer--1---%@", [NSThread currentThread]);
    });

2017-08-24 14:45:20.062 thread[55200:4960926] after-0----<NSThread: 0x600000066e00>{number = 1, name = main}
2017-08-24 14:45:22.261 thread[55200:4960978] affer--1---<NSThread: 0x60000006d0c0>{number = 3, name = (null)}

延時兩秒之后開辟新線程執(zhí)行
柵欄任務(wù)

- (void)barrier {
    dispatch_queue_t queue = dispatch_queue_create("barrier", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        [NSThread sleepForTimeInterval:1];
        NSLog(@"barrier--1---%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        [NSThread sleepForTimeInterval:1];
        NSLog(@"barrier--2---%@", [NSThread currentThread]);
    });
    
//    dispatch_barrier_async(queue, ^{
//        [NSThread sleepForTimeInterval:1];
//        NSLog(@"barrier--3---%@", [NSThread currentThread]);
//    });
    
    dispatch_async(queue, ^{
        [NSThread sleepForTimeInterval:1];
        NSLog(@"barrier--4---%@", [NSThread currentThread]);
    });
}

先看一下在啟用柵欄之前，這幾個任務(wù)應(yīng)該是同時執(zhí)行的

2017-08-24 14:55:51.389 thread[55322:4971612] barrier--4---<NSThread: 0x608000266600>{number = 5, name = (null)}
2017-08-24 14:55:51.389 thread[55322:4971630] barrier--1---<NSThread: 0x600000268e00>{number = 4, name = (null)}
2017-08-24 14:55:51.389 thread[55322:4971614] barrier--2---<NSThread: 0x600000262c00>{number = 3, name = (null)}

在看一下啟用柵欄之后的情況，1和2是同時執(zhí)行，3是在1和2執(zhí)行結(jié)束之后開始執(zhí)行，4是在3結(jié)束之后執(zhí)行

2017-08-24 16:59:53.325 thread[1007:39054] barrier--1---<NSThread: 0x600000269a40>{number = 3, name = (null)}
2017-08-24 16:59:53.325 thread[1007:39070] barrier--2---<NSThread: 0x60800007fb00>{number = 4, name = (null)}
2017-08-24 16:59:54.328 thread[1007:39070] barrier--3---<NSThread: 0x60800007fb00>{number = 4, name = (null)}
2017-08-24 16:59:55.333 thread[1007:39070] barrier--4---<NSThread: 0x60800007fb00>{number = 4, name = (null)}

只執(zhí)行一次的任務(wù)，通常用于單例模式中創(chuàng)建單例，而且是線程安全的

- (void)viewDidLoad {
    [super viewDidLoad];
    [self once];
    [self once];
}

- (void)once {
    NSLog(@"-----once");
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"once---%@", [NSThread currentThread]);
    });
}

看結(jié)果是不是真的塊方法只打印了一次

2017-08-24 17:10:28.742 thread[1043:48637] -----once
2017-08-24 17:10:28.743 thread[1043:48637] once---<NSThread: 0x60800007bac0>{number = 1, name = main}
2017-08-24 17:10:28.743 thread[1043:48637] -----once

在看一下分組任務(wù)

- (void)group {
    dispatch_group_t group =  dispatch_group_create();//創(chuàng)建一個分組
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{//任務(wù)放在group 組中
        [NSThread sleepForTimeInterval:1];
        NSLog(@"group--1---%@", [NSThread currentThread]);
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [NSThread sleepForTimeInterval:1];
        NSLog(@"group--2---%@", [NSThread currentThread]);
    });
    //觀察一個分組任務(wù)全部完成的通知，然后執(zhí)行
    dispatch_group_notify(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [NSThread sleepForTimeInterval:1];
        NSLog(@"group--3---%@", [NSThread currentThread]);
    });
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [NSThread sleepForTimeInterval:2];
        NSLog(@"group--4---%@", [NSThread currentThread]);
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [NSThread sleepForTimeInterval:1];
        NSLog(@"barrier--5---%@", [NSThread currentThread]);
    });
}

2017-08-24 17:25:15.583 thread[1144:62230] group--1---<NSThread: 0x608000261d00>{number = 3, name = (null)}
2017-08-24 17:25:15.583 thread[1144:62247] group--2---<NSThread: 0x6000002633c0>{number = 4, name = (null)}
2017-08-24 17:25:15.583 thread[1144:62248] group--5---<NSThread: 0x60000026a140>{number = 5, name = (null)}
2017-08-24 17:25:16.582 thread[1144:62233] group--4---<NSThread: 0x60000007f8c0>{number = 6, name = (null)}
2017-08-24 17:25:17.588 thread[1144:62233] group--3---<NSThread: 0x60000007f8c0>{number = 6, name = (null)}

從4的執(zhí)行時間我們能看出來通知任務(wù)會等組中的任務(wù)全部完成才會執(zhí)行，不管任務(wù)是在它之前還是在它之后添加，而且從5的執(zhí)行結(jié)果看不會對別的任務(wù)產(chǎn)生影響。

GCD中信號量的使用

信號量(semaphore)是非負(fù)整型變量，除了初始化之外，它只能通過兩個標(biāo)準(zhǔn)原子操作：wait(semap) , signal(semap) ; 來進(jìn)行訪問；
操作也被成為PV原語（P來源于Dutch proberen"測試"，V來源于Dutch verhogen"增加"），而普通整型變量則可以在任何語句塊中被訪問；

在GCD中有semaphore的操作：
dispatch_semaphore_create 創(chuàng)建一個semaphore　
dispatch_semaphore_signal 發(fā)送一個信號　
dispatch_semaphore_wait 等待信號

信號量的主要作用就是控制并發(fā)量，信號量為0則阻塞線程，大于0則不會阻塞。我們通過改變信號量的值，來控制是否阻塞線程，從而控制并發(fā)控制。
來看個例子

- (void)singal {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);//創(chuàng)建一個值為1的信號量
    NSLog(@"singal ----%zd", index);
    for (int index = 0; index < 5; index++) {
        dispatch_async(queue, ^(){
            NSLog(@"singal ----%zd", index);
            [NSThread sleepForTimeInterval:1];
            dispatch_semaphore_signal(semaphore);//信號量+1
        });
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);//試圖把信號量-1，如果值小于0，就等待
    }
}

看結(jié)果

2017-08-24 17:58:42.057 thread[1326:93346] singal ----1
2017-08-24 17:58:42.057 thread[1326:93349] singal ----0
2017-08-24 17:58:43.062 thread[1326:93346] singal ----2
2017-08-24 17:58:43.063 thread[1326:93349] singal ----3
2017-08-24 17:58:44.065 thread[1326:93349] singal ----4

因為我們創(chuàng)建的信號量初始值為1，然后我們是先執(zhí)行添加任務(wù)道隊列，然后-1，所以我們就有兩個并發(fā)。如果我們創(chuàng)建的信號量為0，或者我們先-1，然后添加任務(wù)道隊列，那我們就只有一個并發(fā)，就等于是同步操作。

一些其他的操作

dispatch_queue_t dispatch_get_current_queue(void);//獲取當(dāng)前隊列
// 獲取主隊列
dispatch_queue_t dispatch_get_main_queue(void){
    return DISPATCH_GLOBAL_OBJECT(dispatch_queue_t, _dispatch_main_q);
}
//隊列優(yōu)先級
#define DISPATCH_QUEUE_PRIORITY_HIGH 2
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0
#define DISPATCH_QUEUE_PRIORITY_LOW (-2)
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN
typedef long dispatch_queue_priority_t;
//獲取全局并行隊列
/**
 *參數(shù)：identifier
 *- DISPATCH_QUEUE_PRIORITY_HIGH:         QOS_CLASS_USER_INITIATED
 *- DISPATCH_QUEUE_PRIORITY_DEFAULT:      QOS_CLASS_DEFAULT
 *- DISPATCH_QUEUE_PRIORITY_LOW:          QOS_CLASS_UTILITY
 *- DISPATCH_QUEUE_PRIORITY_BACKGROUND:   QOS_CLASS_BACKGROUND
 *
 *#define DISPATCH_QUEUE_PRIORITY_HIGH 2
 *#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0
 *#define DISPATCH_QUEUE_PRIORITY_LOW (-2)
 *#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN
 **/
dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags);
//當(dāng)指定隊列鍵值改變時，或者是所有屬性值都釋放后，調(diào)用銷毀函數(shù)destructor
void dispatch_queue_set_specific(dispatch_queue_t queue, const void *key,
void *_Nullable context, dispatch_function_t _Nullable destructor);
//獲取隊列某個key內(nèi)容
void *_Nullable dispatch_queue_get_specific(dispatch_queue_t queue, const void *key);
//驗證當(dāng)前塊任務(wù)運(yùn)行在指定隊列上
void dispatch_assert_queue(dispatch_queue_t queue)
DISPATCH_ALIAS_V2(dispatch_assert_queue);
//驗證當(dāng)前塊任務(wù)運(yùn)行在指定隊列上，并且該任務(wù)阻塞隊列中的其它任務(wù)
void dispatch_assert_queue_barrier(dispatch_queue_t queue);
//驗證當(dāng)前塊任務(wù)沒有運(yùn)行在指定隊列上
void dispatch_assert_queue_not(dispatch_queue_t queue)
DISPATCH_ALIAS_V2(dispatch_assert_queue_not);
功能：獲取隊列描述信息
參數(shù)：label：隊列附帶信息，可有可無  attr：隊列屬性值  target：目標(biāo)隊列，相當(dāng)于目標(biāo)隊列計數(shù)加一
返回值：隊列附帶信息
dispatch_queue_t dispatch_queue_create_with_target(const char *_Nullable label,
dispatch_queue_attr_t _Nullable attr, dispatch_queue_t _Nullable target)
//創(chuàng)建時間對象，在指定時間的基礎(chǔ)上再添加一段時間
//when：時間  delta：時間段（納秒）
dispatch_time_t dispatch_time(dispatch_time_t when, int64_t delta);
//創(chuàng)建時間對象，在指定時間的基礎(chǔ)上再添加一段時間
//when：時間  delta時間段（納秒）
返回值：時間對象
dispatch_time_t dispatch_walltime(const struct timespec *_Nullable when, int64_t delta);
//增加隊列引用計數(shù)
void dispatch_retain(dispatch_object_t object);
//減少隊列引用計數(shù)
void dispatch_release(dispatch_object_t object);
//獲取對象應(yīng)用程序上下文
void *_Nullable dispatch_get_context(dispatch_object_t object);
//設(shè)置指定對象的應(yīng)用程序上下文
void dispatch_set_context(dispatch_object_t object, void *_Nullable context);
//掛起隊列
void dispatch_suspend(dispatch_object_t object);
//恢復(fù)隊列
void dispatch_resume(dispatch_object_t object);
//取消對象
void dispatch_cancel(void *object);
//判斷對象是否被取消
long dispatch_testcancel(void *object);