GCD大家用的都比较多，但有时候却搞不太清楚同步异步，并行串行各种组合的应用场景，最近整理了一下。
/*
总结放在前边，如有不对的地方还请指教
名词解释：
同步：不开辟新线程（在当前线程）
异步：开辟新的线程（在新的线程）
串行：(在同一个线程)有序执行
并行：(在多个线程)无序执行
理解：
如果没有开辟新的线程，在当前线程中就只能FIFO，所以同步并行实际也还是串行执行的（并行和异步绑定使用才是有效的）
坑：
”串行&异步“或者”异步&串行“感觉是一样的 后来发现 ”异步串行“这样记才更容易理解如下：
异步串行=开辟新的线程并有序执行（开辟一条新线程有序执行）
异步并行=开辟新的线程&无序执行（开辟多条新线程无序执行）
同步串行=不开辟新线程&有序执行（没有新的线程只能在当前线程有序执行）
同步并行=不开辟新线程&无序执行（没有新的线程只能在当前线程有序执行）
a异步全局队列：
1.创建多个线程
2.无序执行
总结：适用于没有相互依赖关系的网络请求，既单独的网络请求，如：加载一个列表数据
b异步并行队列：（异步全局队列也是并行队列，但是全局队列没有名字不用管理可以直接使用）
1.创建多个线程
2.无序执行
总结：如a
c同步并行队列：
1.不会创建新的线程
2.在当前线程FIFO
总结：没用
d异步串行队列：
1.会创建一条新线程
2.在新的线程上FIFO
总结：适用于相互依赖的网络请求，既下一个任务依赖当前任务，如：图片上传完成后才能发布一条内容《可能例子不太恰当，正常操作可能是图片完成后在回调中直接做发布操作》
e同步串行队列：
1.不会创建新线程
2.在当前线程上FIFO
总结：没用
也就是说基本上只有异步操作的时候才需要用到GCD，其他情况实际上都是在当前线程有序执行的
*/
import UIKit
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
self.globalAsyncQueue()
}
func globalAsyncQueue() {
print("异步全局队列")
//全局队列
let globalQueue = DispatchQueue.global()
let globalQueueGroup = DispatchGroup()
for i in 0..<10 {
globalQueueGroup.enter()
globalQueue.async(execute: {
print("\(Thread.current.description)\(i)")
globalQueueGroup.leave()
})
}
globalQueueGroup.notify(queue: DispatchQueue.main) {
self.concurrentAsyncQueue()
}
/*
异步全局队列：
1.创建多个线程
2.无序执行
*/
}
func concurrentAsyncQueue() {
print("异步并行队列")
//并行队列
let concurrentQueue = DispatchQueue(label: "concurrentQueue", attributes: DispatchQueue.Attributes.concurrent)
let concurrentQueueGroup = DispatchGroup()
for i in 0..<10 {
concurrentQueueGroup.enter()
concurrentQueue.async(execute: {
print("\(Thread.current.description)\(i)")
concurrentQueueGroup.leave()
})
}
//任务完成后,通知主线程
concurrentQueueGroup.notify(queue: DispatchQueue.main) {
self.concurrentSyncQueue()
}
/*
异步并行队列：（异步全局队列也是并行队列类似，但是全局队列没有名字不用管理可以直接使用）
1.创建多个线程
2.无序执行
*/
}
func concurrentSyncQueue() {
print("同步并行队列")
//并行队列
let concurrentQueue = DispatchQueue(label: "concurrentSyncQueue", attributes: DispatchQueue.Attributes.concurrent)
let concurrentQueueGroup = DispatchGroup()
for i in 0..<10 {
concurrentQueueGroup.enter()
concurrentQueue.sync(execute: {
// Thread.sleep(forTimeInterval: 0.3)
print("\(Thread.current.description)\(i)")
concurrentQueueGroup.leave()
})
}
//任务完成后,通知当前线程
concurrentQueueGroup.notify(queue: concurrentQueue) {
self.serialAsyncQueue()
}
/*
同步并行队列：
1.不会创建新的线程
2.在当前线程FIFO
*/
}
func serialAsyncQueue() {
print("异步串行队列")
//串行队列
let serialQueue = DispatchQueue(label: "serialQueue")
let serialQueueGroup = DispatchGroup()
for i in 0..<10 {
serialQueueGroup.enter()
serialQueue.async(execute: {
print("\(Thread.current.description)\(i)")
serialQueueGroup.leave()
})
}
//任务完成后,通知主线程
serialQueueGroup.notify(queue: DispatchQueue.main) {
self.serialSyncQueue()
}
/*
异步串行队列：
1.会创建一条新线程
2.在新的线程上FIFO
*/
}
func serialSyncQueue() {
print("同步串行队列")
//串行队列
let serialQueue = DispatchQueue(label: "serialSyncQueue")
let serialQueueGroup = DispatchGroup()
for i in 0..<10 {
serialQueueGroup.enter()
serialQueue.sync(execute: {
// Thread.sleep(forTimeInterval: 0.3)
print("\(Thread.current.description)\(i)")
serialQueueGroup.leave()
})
}
serialQueueGroup.notify(queue: DispatchQueue.main) {
self.mainAsyncQueue()
}
/*
同步串行队列：
1.不会创建新线程
2.在当前线程上FIFO
*/
}
func mainAsyncQueue() {
print("异步主线程队列")
//串行队列
let mainQueue = DispatchQueue.main
let mainQueueGroup = DispatchGroup()
for i in 0..<10 {
mainQueueGroup.enter()
mainQueue.async(execute: {
// Thread.sleep(forTimeInterval: 0.3)
print("\(Thread.current.description)\(i)")
mainQueueGroup.leave()
})
}
mainQueueGroup.notify(queue: DispatchQueue.main) {
self.mainSyncQueue()
}
/*
异步主线程队列：
1.因为主线程只有一个，所以不会创建新线程
2.在主线程上FIFO
*/
}
func mainSyncQueue() {
print("同步主线程队列,会发生crash，线程死锁,想要测试可以注释return")
//会发生crash，线程死锁
return
//串行队列
let mainQueue = DispatchQueue.main
let mainQueueGroup = DispatchGroup()
for i in 0..<10 {
mainQueueGroup.enter()
mainQueue.sync(execute: {
// Thread.sleep(forTimeInterval: 0.3)
print("\(Thread.current.description)\(i)")
mainQueueGroup.leave()
})
}
mainQueueGroup.notify(queue: DispatchQueue.main) {
print("执行完成")
}
/*
同步主线程队列：
1.不会创建新线程
2.在当前线程上FIFO
*/
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
}
