用了这么久的GCD, 不总结一下实在良心上过不去. 有那么点白那啥的意思. 废话不多说. 走你 ⚔

1 GCD介绍

这里就不搬百度百科或者官方文档了, 简单介绍下, 反正大家都知道. 全名 Grand Central Dispatch,面试的时候别全名都写不出来. 是苹果原生基于C语言的一套多线程开发API.

它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。

1.1 那为什么我们要使用 GCD 呢？

相较于NSThread (swift 里 Thread), GCD的队列能更方便我们多线程之间通讯. 而且使用 GCD 有很多好处啊，具体如下：

• GCD 可用于多核的并行运算；
• GCD 会自动利用更多的 CPU 内核（比如双核、四核）；
• GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）；
• 使用者只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码。

其实吧 , 最重要的一点就是,我不知道如何管理线程 , 但是我又需要多线程或者异步执行一些代码. 所以我用你嘛. 不然我看你做锤子. (背地里说)

2 队列和任务

这俩核心观点 , 答应我 先搞定在去学下面的. 不然你会一团浆糊.

2.1 任务

任务就是需要执行的操作. 白话翻译就是你的某一段代码, 或者说成你需要做的事 例如下载图片. 加载数据. 显示图片等等.

任务的执行有两种方式: 『 同步执行 』 和 『 异步执行 』

• 同步执行

① : 同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
② : 只能在当前线程中执行任务，不具备开启新线程的能力。

• 异步执行

① : 异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
② : 可以在新的线程中执行任务，具备开启新线程的能力。

注意：异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关（下面会讲）。

2.2 队列（Dispatch Queue）

队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。

在 GCD 中有两种队列：『串行队列』 和 『并发队列』。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。

• 串行队列（ Serial Dispatch Queue ）：

每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）

• 并发队列（ Concurrent Dispatch Queue ）：

可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）
并发队列 的并发功能只有在异步（dispatch_async）方法下才有效。

2.3 任务与队列的总结:

其实 GCD 简单使用, 也无非就这两步. 创建或选取现有队列. 同步或者异步添加任务. 因此也就产生了四种组合方式. 具体效果我们接下来去尝试. 根据不同业务需求来使用不同组合.

(由于苹果默认提供了主队列和全局队列给我们, 而全局并发队列可以当成并发队列来看. 因此说是六种组合也是可以的)

3 任务和队列多种组合

说了这么多,先来段代码 ( Show me the code 👿🕶)

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        
        print("1========\(Thread.current)")
        DispatchQueue.main.sync {
            print("2========\(Thread.current)")
        }
        print("3========\(Thread.current)")
    }

}

先猜一猜打印结果.

结果是什么? 1,2,3 ? 还是 1,3,2 ?
这个例子可能很多同学见过 , 或者被坑过. 但是它可以帮助我们很好的检测自己对队列以及任务的了解情况 , 因此经常被拿来当面试题 .

答案是:
打印了

1========<NSThread: 0x6000031e9800>{number = 1, name = main}

然后就崩溃了.

我们来分析一下原因:
前情须知:

主队列是 GCD 自带的一种特殊串行队列。放到主队列的任务都会放到放到主线程执行。

首先需要清除的前提是 viewDidLoad 也是一个任务. 执行在主队列中. 下面我们统称为任务1. 那么当在执行 viewDidLoad 时, 首先打印 1======== , 然后开始同步执行 print("2=======...的任务, 我们下文统称为任务2 .

但是问题来了 , 1执行到2时, 并不开启线程, 然后开始等待任务2完成. 以便继续执行打印 3===. 但是由于串行队列, 后添加的任务2必须等任务1完成才能开始执行. 所以任务2开始等待任务1完成. 哦豁. 死锁了.

简单总结来说:
由于系统默认方法大多是在主队列中同步执行的. 当你在主线程使用主队列再增加同步执行的任务时, 往往你添加的那个方法 也是一个同步任务, 那么就会造成死锁 (至于子线程调用主队列再增加同步执行的任务. 别急, 往下看)

那么怎么解决呢? 聪明的你应该有答案, 我举个例子吧 , 答案不止一种.

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        
        print("1========\(Thread.current)")
        DispatchQueue.global().sync {
            print("2========\(Thread.current)")
        }
//        DispatchQueue.main.sync {
//            print("2========\(Thread.current)")
//        }
        print("3========\(Thread.current)")
    }

}

打印结果:

1========<NSThread: 0x6000038b01c0>{number = 1, name = main}
2========<NSThread: 0x6000038b01c0>{number = 1, name = main}
3========<NSThread: 0x6000038b01c0>{number = 1, name = main}

3.1 任务和队列不同组合方式的区别

先来考虑最基本的使用，也就是当前线程为 『主线程』 的环境下, 也就是在主线程使用这些队列任务组合. 暂时不考虑在队列中嵌套队列等情况.

上面也能看到我们刚刚提到的主队列同步执行任务的死锁问题, 我们也解释了其原因, 记住: 不是因为在串行队列执行同步任务就死锁, 而是在主队列本身就有的任务中添加其他同步任务才会死锁. 千万搞清楚啦

那么在其他线程调用 『主队列』+『同步执行』，则不会阻塞 『主队列』，自然也不会造成死锁问题。最终的结果是：不会开启新线程，串行执行任务。

验证一下:

案例1 🌰

print("1========\(Thread.current)")
DispatchQueue.global().async {
    print("2========\(Thread.current)")
    
    DispatchQueue.main.sync {
        print("3========\(Thread.current)")
    }
    print("4========\(Thread.current)")
}

print("5========\(Thread.current)")

打印结果:

1========<NSThread: 0x6000029286c0>{number = 1, name = main}
5========<NSThread: 0x6000029286c0>{number = 1, name = main}
2========<NSThread: 0x60000297edc0>{number = 3, name = (null)}
3========<NSThread: 0x6000029286c0>{number = 1, name = main}
4========<NSThread: 0x60000297edc0>{number = 3, name = (null)}

小结:
上面案例中我们在全局并发队列中异步执行一个任务, 打印2 , 4 可以看出开辟了一个新的线程. 在这个线程中调用主队列同步执行任务, 回到了主线程打印出3.验证了我们子线程调用主队列+同步执行任务并不会造成死锁的杰伦

当然你也可以再验证一下 在打印3任务下面再增加一个 DispatchQueue.main.sync 任务, 试一下死锁什么时候会触发.

这里搞清楚了. 那么再提问: 在子线程执行就一定不会了吗. 千万不要被表面上刨的坑给埋住了哦.

案例2 🌰

let queue = DispatchQueue.init(label: "lb") //默认创建串行队列
//        let queue = DispatchQueue(label: "lb", attributes: .concurrent) //创建并发队列
queue.async { // 异步执行 + 串行队列
    print("1当前线程:\(Thread.current)")
    queue.sync {  // 同步执行 + 当前串行队列
        Thread.sleep(forTimeInterval: 5)
        print("2当前线程:\(Thread.current)")
    }
    print("3当前线程:\(Thread.current)")
}

运行, 你试试.
打印:

1当前线程:<NSThread: 0x60000082f4c0>{number = 3, name = (null)}

然后崩溃...

你该说了, 你玩我呢?
别急. 我们要时刻记住一点, 死锁的本质是什么. 是资源的占用或任务调度的顺序产生矛盾.

那么我们顺着这个案例走:

• 串行队列异步执行任务, 打印结果验证了开辟了一条线程. 然后我们又在这个串行队列的其中一个任务1中加了一个同步任务2.

• 当执行完打印1, 开始执行任务2, 但是我们的串行队列说了, 🚫不行, 1没走完呢, 你走🔨你走. 任务2开始等1走完, 任务1得等任务2走完才能继续往下走啊.

至于解决方法就不在多说了. 多种常规操作自己搞去.

那么就死锁问题来了总结最终版:

多线程间的死锁的根源大多在于任务的调度顺序和资源的占用访问. 因此不管在哪个线程, 究其根本总结为 : 当一个串行队列中有一个任务 ( 我可不管你是同步还是异步 ),嵌套了一个同步任务时, 就会造成死锁.

至此: 任务和队列的多重组合情况以及死锁问题我们讲述清楚了. 下篇博客会继续列举 GCD 的基本使用、线程间的通信、以及一些常用其他方法和梳理理解.