1. GCD 簡介

什么是 GCD 呢?

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

為什么要用 GCD 呢逗余？

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

2. GCD 任務(wù)和隊列

任務(wù)

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

• 同步執(zhí)行（sync）：
  • 同步添加任務(wù)到指定的隊列中，在添加的任務(wù)執(zhí)行結(jié)束之前宪睹，會一直等待愁茁，直到隊列里面的任務(wù)完成之后再繼續(xù)執(zhí)行。
  • 只能在當(dāng)前線程中執(zhí)行任務(wù)亭病，不具備開啟新線程的能力鹅很。
• 異步執(zhí)行（async）：
  • 異步添加任務(wù)到指定的隊列中，它不會做任何等待罪帖，可以繼續(xù)執(zhí)行任務(wù)促煮。
  • 可以在新的線程中執(zhí)行任務(wù)，具備開啟新線程的能力整袁。

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

隊列（Dispatch Queue）

這里的隊列指執(zhí)行任務(wù)的等待隊列绳匀，即用來存放任務(wù)的隊列。隊列是一種特殊的線性表炸客，采用 FIFO（先進(jìn)先出）的原則疾棵，即新任務(wù)總是被插入到隊列的末尾，而讀取任務(wù)的時候總是從隊列的頭部開始讀取痹仙。每讀取一個任務(wù)是尔，則從隊列中釋放一個任務(wù)。

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

• 串行隊列（Serial Dispatch Queue）：

  • 每次只有一個任務(wù)被執(zhí)行梨州。讓任務(wù)一個接著一個地執(zhí)行。（只開啟一個線程田轧，一個任務(wù)執(zhí)行完畢后暴匠，再執(zhí)行下一個任務(wù)）

    
    
    串行隊列
• 并發(fā)隊列（Concurrent Dispatch Queue）：

  • 可以讓多個任務(wù)并發(fā)（同時）執(zhí)行。（可以開啟多個線程傻粘，并且同時執(zhí)行任務(wù)）

    
    
    并發(fā)隊列

注意：并發(fā)隊列的并發(fā)功能只有在異步（dispatch_async）函數(shù)下才有效

3. GCD 的使用步驟

1. 創(chuàng)建一個隊列（串行隊列或并發(fā)隊列）
2. 將任務(wù)追加到任務(wù)的等待隊列中每窖，然后系統(tǒng)就會根據(jù)任務(wù)類型執(zhí)行任務(wù)（同步執(zhí)行或異步執(zhí)行）

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

• 可以使用dispatch_queue_create來創(chuàng)建隊列帮掉，需要傳入兩個參數(shù)，第一個參數(shù)表示隊列的唯一標(biāo)識符窒典，用于 DEBUG蟆炊，可為空，Dispatch Queue 的名稱推薦使用應(yīng)用程序 ID 這種逆序全程域名瀑志；第二個參數(shù)用來識別是串行隊列還是并發(fā)隊列涩搓。DISPATCH_QUEUE_SERIAL 表示串行隊列，DISPATCH_QUEUE_CONCURRENT 表示并發(fā)隊列劈猪。

// objective-c寫法
// 串行隊列的創(chuàng)建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
// 并發(fā)隊列的創(chuàng)建方法
let queue = DispatchQueue(label: "com.David.testQueue")

// swift寫法
// 串行隊列的創(chuàng)建方法
let queue = DispatchQueue(label:"com.David.testQueue")
// 并發(fā)隊列的創(chuàng)建方法
let queue = DispatchQueue(label:"com.David.testQueue", qos:.utility, attributes:.concurrent)

• 對于串行隊列昧甘，GCD 提供了的一種特殊的串行隊列：主隊列（Main Dispatch Queue）。
  • 所有放在主隊列中的任務(wù)战得，都會放到主線程中執(zhí)行充边。
  • 可使用dispatch_get_main_queue()獲得主隊列。

// 主隊列的獲取方法
// objective-c寫法
dispatch_queue_t queue = dispatch_get_main_queue();
// swift寫法
let mainQueue = DispatchQueue.main

• 對于并發(fā)隊列常侦，GCD 默認(rèn)提供了全局并發(fā)隊列（Global Dispatch Queue）浇冰。
  • 可以使用dispatch_get_global_queue來獲取。需要傳入兩個參數(shù)聋亡。第一個參數(shù)表示隊列優(yōu)先級肘习，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數(shù)暫時沒用坡倔，用0即可井厌。

// 全局并發(fā)隊列的獲取方法
// objective-c寫法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// swift寫法
let globalQueue = DispatchQueue.global()

3.2 任務(wù)的創(chuàng)建方法

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

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

//swift寫法
queue.sync {
// 這里放同步執(zhí)行任務(wù)代碼
}
queue.async {
// 這里放異步執(zhí)行任務(wù)代碼
}

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

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

2. 異步執(zhí)行 + 并發(fā)隊列
3. 同步執(zhí)行 + 串行隊列
4. 異步執(zhí)行 + 串行隊列

實際上，剛才還說了兩種特殊隊列：全局并發(fā)隊列港柜、主隊列请契。全局并發(fā)隊列可以作為普通并發(fā)隊列來使用。但是主隊列因為有點特殊夏醉，所以我們就又多了兩種組合方式爽锥。這樣就有六種不同的組合方式了。

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

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

4. GCD 的基本使用

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

• 在當(dāng)前線程中執(zhí)行任務(wù)雇毫，不會開啟新線程，執(zhí)行完一個任務(wù)踩蔚，再執(zhí)行下一個任務(wù)

/**
* 同步執(zhí)行 + 并發(fā)隊列
* 特點：在當(dāng)前線程中執(zhí)行任務(wù)棚放，不會開啟新線程，執(zhí)行完一個任務(wù)馅闽，再執(zhí)行下一個任務(wù)飘蚯。
*/
func syncConcurrent() {
    print("currentThread---\(Thread.current)")
    print("syncConcurrent---begin")
    let queue = DispatchQueue(label:"com.David.testQueue", qos:.utility, attributes:.concurrent)
    queue.sync {
        sleep(3)
        print("1---\(Thread.current)")
    }
    print("middle1")
    queue.sync {
        sleep(2)
        print("2---\(Thread.current)")
    }
    print("middle2")
    queue.sync {
        sleep(1)
        print("3---\(Thread.current)")
    }
    print("syncConcurrent---end")
}

currentThread---<NSThread: 0x600001996880>{number = 1, name = main}
syncConcurrent---begin
1---<NSThread: 0x600001996880>{number = 1, name = main}
middle1
2---<NSThread: 0x600001996880>{number = 1, name = main}
middle2
3---<NSThread: 0x600001996880>{number = 1, name = main}
syncConcurrent---end

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

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

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

• 可以開啟多個線程默色，任務(wù)交替（同時）執(zhí)行球凰。

/**
* 異步執(zhí)行 + 并發(fā)隊列
* 特點：可以開啟多個線程，任務(wù)交替（同時）執(zhí)行腿宰。
*/
func asyncConcurrent() {
    print("currentThread---\(Thread.current)")
    print("asyncConcurrent---begin")
    let queue = DispatchQueue(label:"com.david.testQueue", qos:.utility, attributes:.concurrent)
    queue.async {
        sleep(3)
        print("1---\(Thread.current)")
    }
    print("middle1")
    queue.async {
        sleep(2)
        print("2---\(Thread.current)")
    }
    print("middle2")
    queue.async {
        sleep(1)
        print("3---\(Thread.current)")
    }
    print("asyncConcurrent---end")
}

currentThread---<NSThread: 0x600002379240>{number = 1, name = main}
asyncConcurrent---begin
middle1
middle2
asyncConcurrent---end
3---<NSThread: 0x600002315880>{number = 3, name = (null)}
2---<NSThread: 0x6000023299c0>{number = 4, name = (null)}
1---<NSThread: 0x600002338a40>{number = 5, name = (null)}

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

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

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

• 不會開啟新線程汁尺，在當(dāng)前線程執(zhí)行任務(wù)法精。任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)亿虽。

/**
* 同步執(zhí)行 + 串行隊列
* 特點：不會開啟新線程菱涤，在當(dāng)前線程執(zhí)行任務(wù)。任務(wù)是串行的洛勉，執(zhí)行完一個任務(wù)粘秆，再執(zhí)行下一個任務(wù)。
*/
func syncSerial() {
    print("currentThread---\(Thread.current)")
    print("syncSerial---begin")
    let queue = DispatchQueue(label:"com.David.testQueue")
    queue.sync {
        sleep(3)
        print("1---\(Thread.current)")
    }
    print("middle1")
    queue.sync {
        sleep(2)
        print("2---\(Thread.current)")
    }
    print("middle2")
    queue.sync {
        sleep(1)
        print("3---\(Thread.current)")
    }
    sleep(1)
    print("syncConcurrent---end")
}

currentThread---<NSThread: 0x6000007e1900>{number = 1, name = main}
syncConcurrent---begin
1---<NSThread: 0x6000007e1900>{number = 1, name = main}
middle1
2---<NSThread: 0x6000007e1900>{number = 1, name = main}
middle2
3---<NSThread: 0x6000007e1900>{number = 1, name = main}
syncConcurrent---end

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

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

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

• 會開啟新線程，但是因為任務(wù)是串行的输拇，執(zhí)行完一個任務(wù)摘符，再執(zhí)行下一個任務(wù)

/**
* 異步執(zhí)行 + 串行隊列
* 特點：會開啟新線程，但是因為任務(wù)是串行的策吠，執(zhí)行完一個任務(wù)逛裤，再執(zhí)行下一個任務(wù)。
*/
func asyncSerial() {
    print("currentThread---\(Thread.current)")
    print("asyncSerial---begin")
    let queue = DispatchQueue(label:"com.David.testQueue")
    queue.async {
        sleep(3)
        print("1---\(Thread.current)")
    }
    print("middle1")
    queue.async {
        sleep(2)
        print("2---\(Thread.current)")
    }
    print("middle2")
    queue.async {
        sleep(1)
        print("3---\(Thread.current)")
    }
    sleep(1)
    print("asyncSerial---end")
}

currentThread---<NSThread: 0x600001ead9c0>{number = 1, name = main}
asyncSerial---begin
middle1
middle2
asyncSerial---end
1---<NSThread: 0x600001ecc000>{number = 3, name = (null)}
2---<NSThread: 0x600001ecc000>{number = 3, name = (null)}
3---<NSThread: 0x600001ecc000>{number = 3, name = (null)}

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

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

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

同步執(zhí)行 + 主隊列在不同線程中調(diào)用結(jié)果也是不一樣跋理，在主線程中調(diào)用會出現(xiàn)死鎖择克，而在其他線程中則不會。

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

• 互相等待卡住不可行

/**
* 同步執(zhí)行 + 主隊列
* 特點(主線程調(diào)用)：互等卡主不執(zhí)行前普。
* 特點(其他線程調(diào)用)：不會開啟新線程祠饺，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)汁政。
*/
func syncMain() {
    print("currentThread---\(Thread.current)")
    print("syncMain---begin")
    let queue = DispatchQueue.main
    queue.sync {
        sleep(3)
        print("1---\(Thread.current)")
    }
    print("middle1")
    queue.sync {
        sleep(2)
        print("2---\(Thread.current)")
    }
    print("middle2")
    queue.sync {
        sleep(1)
        print("3---\(Thread.current)")
    }
    print("syncMain---end")
}

currentThread---<NSThread: 0x600003f1e780>{number = 1, name = main}
syncMain---begin

syncMain Error

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

• 在主線程中使用同步執(zhí)行 + 主隊列，追加到主線程的任務(wù)1缀旁、任務(wù)2记劈、任務(wù)3都不再執(zhí)行了，而且syncMain---end也沒有打印并巍，在XCode 9上還會報崩潰目木。這是為什么呢？

這是因為我們在主線程中執(zhí)行syncMain方法，相當(dāng)于把syncMain任務(wù)放到了主線程的隊列中刽射。而同步執(zhí)行會等待當(dāng)前隊列中的任務(wù)執(zhí)行完畢军拟，才會接著執(zhí)行。那么當(dāng)我們把任務(wù)1追加到主隊列中誓禁，任務(wù)1就在等待主線程處理完syncMain任務(wù)懈息。而syncMain任務(wù)需要等待任務(wù)1執(zhí)行完畢，才能接著執(zhí)行摹恰。
那么辫继，現(xiàn)在的情況就是syncMain任務(wù)和任務(wù)1都在等對方執(zhí)行完畢。這樣大家互相等待俗慈，所以就卡住了姑宽，所以我們的任務(wù)執(zhí)行不了，而且syncMain---end也沒有打印年局。

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

• 只在主線程中執(zhí)行任務(wù)吓笙，執(zhí)行完一個任務(wù)衷笋，再執(zhí)行下一個任務(wù)。

/**
* 異步執(zhí)行 + 主隊列
* 特點：只在主線程中執(zhí)行任務(wù)瘦穆，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)
*/
func asyncMain() {
    print("currentThread---\(Thread.current)")
    print("asyncMain---begin")
    let queue = DispatchQueue.main
    queue.async {
        sleep(3)
        print("1---\(Thread.current)")
    }
    print("middle1")
    queue.async {
        sleep(2)
        print("2---\(Thread.current)")
    }
    print("middle2")
    queue.async {
        sleep(1)
        print("3---\(Thread.current)")
    }
    print("asyncMain---end")
}

currentThread---<NSThread: 0x6000038de800>{number = 1, name = main}
asyncMain---begin
middle1
middle2
asyncMain---end
1---<NSThread: 0x6000038de800>{number = 1, name = main}
2---<NSThread: 0x6000038de800>{number = 1, name = main}
3---<NSThread: 0x6000038de800>{number = 1, name = main}

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

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

4.8 同步執(zhí)行 + 全局隊列

/**
* 同步執(zhí)行 + 全局（并發(fā)）隊列
* 特點：在當(dāng)前線程中執(zhí)行任務(wù)蒂萎，不會開啟新線程秆吵，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)五慈。
*/
func asyncGlobal() {
    print("currentThread---\(Thread.current)")
    print("asyncMain---begin")
    let queue = DispatchQueue.global()
    queue.async {
        sleep(3)
        print("1---\(Thread.current)")
    }
    print("middle1")
    queue.async {
        sleep(2)
        print("2---\(Thread.current)")
    }
    print("middle2")
    queue.async {
        sleep(1)
        print("3---\(Thread.current)")
    }
    print("asyncGlobal---end")
}

currentThread---<NSThread: 0x600002c868c0>{number = 1, name = main}
syncGlobal---begin
1---<NSThread: 0x600002c868c0>{number = 1, name = main}
middle1
2---<NSThread: 0x600002c868c0>{number = 1, name = main}
middle2
3---<NSThread: 0x600002c868c0>{number = 1, name = main}
syncMain---end

4.7 異步執(zhí)行 + 全局隊列

func asyncGlobal() {
/**
* 異步執(zhí)行 + 全局（并發(fā)）隊列
* 特點：可以開啟多個線程纳寂，任務(wù)交替（同時）執(zhí)行。
*/
    print("currentThread---\(Thread.current)")
    print("asyncMain---begin")
    let queue = DispatchQueue.global()
    queue.async {
        sleep(3)
        print("1---\(Thread.current)")
    }
    print("middle1")
    queue.async {
        sleep(2)
        print("2---\(Thread.current)")
    }
    print("middle2")
    queue.async {
        sleep(1)
        print("3---\(Thread.current)")
    }
    print("asyncGlobal---end")
}

currentThread---<NSThread: 0x600001c3e880>{number = 1, name = main}
asyncMain---begin
middle1
middle2
asyncGlobal---end
3---<NSThread: 0x600001c5c040>{number = 3, name = (null)}
2---<NSThread: 0x600001c61ec0>{number = 4, name = (null)}
1---<NSThread: 0x600001c76080>{number = 5, name = (null)}

5. GCD 線程間的通信

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

func communication() {
    print("currentThread---\(Thread.current)")
    print("communication---begin")
    DispatchQueue.global().async {
        sleep(1)
        print("1---\(Thread.current)")
        DispatchQueue.main.async {
            sleep(2)
            print("2---\(Thread.current)")
        }
    }
    print("communication---end")
}

currentThread---<NSThread: 0x60000035fbc0>{number = 1, name = main}

communication---begin
communication---end
1---<NSThread: 0x60000033a5c0>{number = 3, name = (null)}
2---<NSThread: 0x60000035fbc0>{number = 1, name = main}

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

6. GCD 的其他方法

6.1 GCD 柵欄方法：dispatch_barrier_async

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

func barrier() {
    print("currentThread---\(Thread.current)")
    print("communication---begin")
    let queue = DispatchQueue(label:"com.David.testQueue", qos:.default, attributes:.concurrent)
    //        let queue = DispatchQueue.global()
    queue.async {
        sleep(1)
        print("1---\(Thread.current)")
    }
    queue.async(group: nil, qos: .default, flags: .barrier) {
        sleep(2)
        print("barrier---\(Thread.current)")
    }
    queue.async {
        sleep(1)
        print("2---\(Thread.current)")
    }
    queue.async {
        sleep(1)
        print("3---\(Thread.current)")
    }
    print("communication---end")
}

currentThread---<NSThread: 0x6000016d68c0>{number = 1, name = main}
communication---beginc
communication---end
1---<NSThread: 0x6000016b5940>{number = 3, name = (null)}
barrier---<NSThread: 0x6000016b4b40>{number = 4, name = (null)}
3---<NSThread: 0x6000016b5940>{number = 3, name = (null)}
2---<NSThread: 0x6000016b4b40>{number = 4, name = (null)}

如果queue替換成下面global，實際是錯的

let queue = DispatchQueue.global()

currentThread---<NSThread: 0x60000225ad00>{number = 1, name = main}
communication---begin
communication---end
1---<NSThread: 0x600002235a00>{number = 5, name = (null)}
2---<NSThread: 0x60000223a440>{number = 4, name = (null)}
3---<NSThread: 0x600002230980>{number = 3, name = (null)}
barrier---<NSThread: 0x60000223a680>{number = 6, name = (null)}

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

我們經(jīng)常會遇到這樣的需求：在指定時間（例如3秒）之后執(zhí)行某個任務(wù)曲聂∨海可以用 GCD 的dispatch_after函數(shù)來實現(xiàn)。
需要注意的是：dispatch_after函數(shù)并不是在指定時間之后才開始執(zhí)行處理朋腋，而是在指定時間之后將任務(wù)追加到主隊列中齐疙。嚴(yán)格來說，這個時間并不是絕對準(zhǔn)確的旭咽，但想要大致延遲執(zhí)行任務(wù)贞奋，dispatch_after函數(shù)是很有效的。

/**
* 延時執(zhí)行方法 dispatch_after
*/
func after() {
    print("currentThread---\(Thread.current)")
    print("after---begin")
    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+2) {
        print("after---\(Thread.current)")
    }
    print("after---end")
}

currentThread---<NSThread: 0x6000027d99c0>{number = 1, name = main}
after---begin
after---end
after---<NSThread: 0x6000027d99c0>{number = 1, name = main}

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

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

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

6.4 GCD 快速迭代方法：dispatch_apply

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

如果是在串行隊列中使用 dispatch_apply，那么就和 for 循環(huán)一樣，按順序同步執(zhí)行匈勋±衤茫可這樣就體現(xiàn)不出快速迭代的意義了。
我們可以利用并發(fā)隊列進(jìn)行異步執(zhí)行洽洁。比如說遍歷 0~5 這6個數(shù)字痘系，for 循環(huán)的做法是每次取出一個元素，逐個遍歷饿自。dispatch_apply 可以 在多個線程中同時（異步）遍歷多個數(shù)字汰翠。
還有一點，無論是在串行隊列昭雌，還是異步隊列中复唤，dispatch_apply 都會等待全部任務(wù)執(zhí)行完畢，這點就像是同步操作烛卧，也像是隊列組中的 dispatch_group_wait方法佛纫。

func apply() {
    print("currentThread---\(Thread.current)")
    print("apply---begin")
    DispatchQueue.concurrentPerform(iterations: 3) { (index) in
        sleep(1)
        print("apply\(index)---\(Thread.current)")
    }
    print("apply---end")
}

currentThread---<NSThread: 0x6000021819c0>{number = 1, name = main}
apply---begin
apply1---<NSThread: 0x6000021e6700>{number = 4, name = (null)}
apply0---<NSThread: 0x6000021819c0>{number = 1, name = main}
apply2---<NSThread: 0x6000021dd5c0>{number = 3, name = (null)}
apply---end

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

GCD 隊列組：dispatch_group

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

• 調(diào)用隊列組的 dispatch_group_async 先把任務(wù)放到隊列中蜈漓，然后將隊列放入隊列組中∩序颍或者使用隊列組的 dispatch_group_enter迎变、dispatch_group_leave 組合 來實現(xiàn) dispatch_group_async。
• 調(diào)用隊列組的 dispatch_group_notify 回到指定線程執(zhí)行任務(wù)飘言∫滦危或者使用 dispatch_group_wait 回到當(dāng)前線程繼續(xù)向下執(zhí)行（會阻塞當(dāng)前線程）。

dispatch_group_notify

• 監(jiān)聽 group 中任務(wù)的完成狀態(tài)姿鸿，當(dāng)所有的任務(wù)都執(zhí)行完成后谆吴，追加任務(wù)到 group 中，并執(zhí)行任務(wù)苛预。

/**
* 隊列組 dispatch_group_notify
*/
func groupNotify() {
    print("currentThread---\(Thread.current)")
    print("groupNotify---begin")
    let queue = DispatchQueue.global()
    let group = DispatchGroup()
    queue.async(group: group) {
        sleep(1)
        print("1---\(Thread.current)")
    }
    queue.async(group: group) {
        sleep(2)
        print("2---\(Thread.current)")
    }
    group.notify(queue: queue) {
        sleep(1)
        print("3---\(Thread.current)")
    }
    print("groupNotify---end")
}

currentThread---<NSThread: 0x600002caa8c0>{number = 1, name = main}
groupNotify---begin
groupNotify---end
1---<NSThread: 0x600002ce1a00>{number = 3, name = (null)}
2---<NSThread: 0x600002cc5f00>{number = 4, name = (null)}
3---<NSThread: 0x600002cc5f00>{number = 4, name = (null)}

6.5.2 dispatch_group_wait

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

/**
* 隊列組 dispatch_group_wait
*/
func groupWait() {
    print("currentThread---\(Thread.current)")
    print("groupWait---begin")
    let queue = DispatchQueue.global()
    let group = DispatchGroup()
    queue.async(group: group) {
        sleep(2)
        print("1---\(Thread.current)")
    }
    queue.async(group: group) {
        sleep(1)
        print("2---\(Thread.current)")
    }
    group.wait()
    print("groupWait---end")
}

currentThread---<NSThread: 0x6000001f28c0>{number = 1, name = main}
groupWait---begin
2---<NSThread: 0x600000191c80>{number = 3, name = (null)}
1---<NSThread: 0x6000001bfd40>{number = 4, name = (null)}
groupWait---end

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

6.5.3 dispatch_group_enter糖耸、dispatch_group_leave

-dispatch_group_enter 標(biāo)志著一個任務(wù)追加到 group，執(zhí)行一次丘薛，相當(dāng)于 group 中未執(zhí)行完畢任務(wù)數(shù)+1

• dispatch_group_leave 標(biāo)志著一個任務(wù)離開了 group嘉竟，執(zhí)行一次，相當(dāng)于 group 中未執(zhí)行完畢任務(wù)數(shù)-1洋侨。
• 當(dāng) group 中未執(zhí)行完畢任務(wù)數(shù)為0的時候舍扰，才會使dispatch_group_wait解除阻塞，以及執(zhí)行追加到dispatch_group_notify中的任務(wù)希坚。

func groupEnterAndLeave() {
    print("currentThread---\(Thread.current)")
    print("groupEnterAndLeave---begin")
    let queue = DispatchQueue.global()
    let group = DispatchGroup()
    group.enter()
    queue.async() {
        sleep(2)
        print("1---\(Thread.current)")
        group.leave()
    }
    group.enter()
    queue.async() {
        sleep(1)
        print("2---\(Thread.current)")
        group.leave()
    }
    group.notify(queue: queue) {
        sleep(1)
        print("3---\(Thread.current)")
    }
    print("groupEnterAndLeave---end")
}

currentThread---<NSThread: 0x600002bf68c0>{number = 1, name = main}
groupEnterAndLeave---begin
groupEnterAndLeave---end
2---<NSThread: 0x600002b9c700>{number = 3, name = (null)}
1---<NSThread: 0x600002b991c0>{number = 4, name = (null)}
3---<NSThread: 0x600002b991c0>{number = 4, name = (null)}

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

6.6 GCD 信號量：dispatch_semaphore

GCD 中的信號量是指 Dispatch Semaphore播急，是持有計數(shù)的信號。類似于過高速路收費站的欄桿售睹∽可以通過時，打開欄桿昌妹，不可以通過時捶枢，關(guān)閉欄桿。在 Dispatch Semaphore 中飞崖，使用計數(shù)來完成這個功能烂叔，計數(shù)為0時等待，不可通過固歪。計數(shù)為1或大于1時蒜鸡，計數(shù)減1且不等待，可通過牢裳。
Dispatch Semaphore 提供了三個函數(shù)逢防。

• dispatch_semaphore_create：創(chuàng)建一個Semaphore并初始化信號的總量

• dispatch_semaphore_signal：發(fā)送一個信號，讓信號總量加1

• dispatch_semaphore_wait：可以使總信號量減1蒲讯，當(dāng)信號總量為0時就會一直等待（阻塞所在線程）忘朝，否則就可以正常執(zhí)行。

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

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

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

6.6.1 Dispatch Semaphore 線程同步

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

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

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

func semaphoreSync() {
    print("currentThread---\(Thread.current)")
    print("semaphoreSync---begin")
    let queue = DispatchQueue.global()
    let semaphore = DispatchSemaphore(value: 0)
    var number = 0
    queue.async {
        sleep(2)
        number = 100
        print("1---\(Thread.current)")
        semaphore.signal()
    }
    semaphore.wait()
    print("semaphoreSync---end,number = \(number)")
}

currentThread---<NSThread: 0x600003ce59c0>{number = 1, name = main}
semaphoreSync---begin
1---<NSThread: 0x600003cbc800>{number = 3, name = (null)}
semaphoreSync---end,number = 100

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

• semaphore---end 是在執(zhí)行完 number = 100; 之后才打印的莫湘。而且輸出結(jié)果 number 為 100。
  這是因為異步執(zhí)行不會做任何等待郑气，可以繼續(xù)執(zhí)行任務(wù)幅垮。異步執(zhí)行將任務(wù)1追加到隊列之后，不做等待尾组，接著執(zhí)行dispatch_semaphore_wait方法忙芒。此時 semaphore == 0，當(dāng)前線程進(jìn)入等待狀態(tài)讳侨。然后呵萨，異步任務(wù)1開始執(zhí)行。任務(wù)1執(zhí)行到dispatch_semaphore_signal之后跨跨，總信號量潮峦，此時 semaphore == 1，dispatch_semaphore_wait方法使總信號量減1歹叮，正在被阻塞的線程（主線程）恢復(fù)繼續(xù)執(zhí)行跑杭。最后打印semaphore---end,number = 100。這樣就實現(xiàn)了線程同步咆耿，將異步執(zhí)行任務(wù)轉(zhuǎn)換為同步執(zhí)行任務(wù)德谅。

7 考題：GCD來實現(xiàn)讀寫操作

private let queue = DispatchQueue(label: "com.davie.readwrite", attributes: .concurrent)
private var _someString: NSString?
var someString:NSString? {
    get {
        var tempString:NSString?
        let semphore = DispatchSemaphore(value: 1)
        queue.async() {
            sleep(1)
            tempString = self._someString
            print("read:\(tempString ?? "NULL"),\(semphore),\(Thread.current)")
            semphore.signal()
        }
        semphore.wait()
        return tempString
    }
    set {
        // 寫數(shù)據(jù)時使用串行
        queue.async(flags: .barrier) {
        sleep(1)
        self._someString = newValue
        print("write:\(self._someString ?? "NULL"),\(Thread.current)")
        }
    }
}

var a = self.someString
self.someString = "22"
a = self.someString
a = self.someString

read:NULL,<OS_dispatch_semaphore: 0x600000d02e40>,<NSThread: 0x600003b79200>{number = 3, name = (null)}
write:22,<NSThread: 0x600003b79200>{number = 3, name = (null)}
read:22,<OS_dispatch_semaphore: 0x600000d03390>,<NSThread: 0x600003b79200>{number = 3, name = (null)}
read:22,<OS_dispatch_semaphore: 0x600000d033e0>,<NSThread: 0x600003b72880>{number = 4, name = (null)}

如果用let queue = DispatchQueue.global() 實際barrier模式的柵欄不起作用

read:NULL,<OS_dispatch_semaphore: 0x600001fdcaa0>,<NSThread: 0x6000029a1f40>{number = 4, name = (null)}
read:NULL,<OS_dispatch_semaphore: 0x600001fdd0e0>,<NSThread: 0x600002993b40>{number = 5, name = (null)}
read:NULL,<OS_dispatch_semaphore: 0x600001fdd5e0>,<NSThread: 0x6000029a1f00>{number = 3, name = (null)}
write:22,<NSThread: 0x60000299c800>{number = 6, name = (null)}

如果用let semphore = DispatchSemaphore(value: 0),實際讀模式就變成了用了同一個線程的串型，后2次read中間等待了一秒

read:NULL,<OS_dispatch_semaphore: 0x6000033f62b0>,<NSThread: 0x600000585480>{number = 3, name = (null)}
write:22,<NSThread: 0x600000585480>{number = 3, name = (null)}
read:22,<OS_dispatch_semaphore: 0x6000033f62b0>,<NSThread: 0x600000585480>{number = 3, name = (null)}
read:22,<OS_dispatch_semaphore: 0x6000033d0410>,<NSThread: 0x600000585480>{number = 3, name = (null)}

參考：

iOS 多線程：『GCD』詳盡總結(jié)