加深对GCD的印象（Swift）

为加深对GCD的印象和了解，抽时间在playground上演练一遍

import UIKit

let item1 = DispatchWorkItem {
    for i in 0...4{
        print("item1 -> \(i)  thread: \(Thread.current)")
    }
}


let item2 = DispatchWorkItem {
    for i in 0...4{
        print("item2 -> \(i)  thread: \(Thread.current)")
    }
}

let item3 = DispatchWorkItem {
    for i in 0...4{
        print("item3 -> \(i)  thread: \(Thread.current)")
    }
}

let item4 = DispatchWorkItem {
    for i in 0...4{
        print("item4 -> \(i)  thread: \(Thread.current)")
    }
}


//主队列是串行队列 运行在主线程上
let mainQueue = DispatchQueue.main
mainQueue.async(execute: item1)
mainQueue.async(execute: item2)
mainQueue.async(execute: item3)
mainQueue.async(execute: item4)

//主队列执行同步任务会死锁，原因是相互等待执行，也就是说主队列只能执行异步任务
mainQueue.sync(execute: item4)

//global为全局队列，并行队列，能开启多个线程（异步）
//并行队列嵌套 任务不会引起死锁
let globalQueue = DispatchQueue.global()
//同步任务会交给主线程按顺序处理
globalQueue.sync(execute: item1)
globalQueue.sync(execute: item2)
globalQueue.sync(execute: item3)
globalQueue.sync(execute: item4)

//异步任务开启了多个线程，有可能一个线程处理多个异步任务，并不是每个异步都有一个独立的线程
//线程之间执行顺序不固定
globalQueue.async(execute: item1)
globalQueue.async(execute: item2)
globalQueue.async(execute: item3)
globalQueue.async(execute: item4)

//自定义串行队列
let serialQueue = DispatchQueue(label: "serial")
//自定义串行队列，异步任务，开启了线程，但是只会开启一个线程，任务按顺序执行
serialQueue.async(execute: item1)
serialQueue.async(execute: item2)
serialQueue.async(execute: item3)
serialQueue.async(execute: item4)
//自定义串行队列，同步任务，没有开启线程，运行在主线程上，任务按顺序执行
serialQueue.sync(execute: item1)
serialQueue.sync(execute: item2)
serialQueue.sync(execute: item3)
serialQueue.sync(execute: item4)

//自定义串行队列，异步嵌套异步不会死锁
serialQueue.async {
    print("异步嵌套异步1")
    serialQueue.async {
        print("异步嵌套异步2")
    }
}
//自定义串行队列，同步嵌套异步不会死锁
serialQueue.sync {
    print("同步嵌套异步1")
    serialQueue.async {
        print("同步嵌套异步2")
    }
}

//自定义串行队列，异步嵌套同步会死锁
serialQueue.async {
    print("异步嵌套同步1")
    serialQueue.sync {
        print("异步嵌套同步2")
    }
}

//自定义串行队列，同步嵌套同步会死锁
serialQueue.sync {
    print("同步嵌套同步1")
    serialQueue.sync {
        print("同步嵌套同步2")
    }
}

//🔼总结自定义串行队列死锁，不能内部嵌套同步任务

//自定义并行队列,的特性和 global一样，区别只是，global是全部并行队列，concurrentQueue是自定义的，
//还有个区别是 global的挂起方法是无效的，global.suspend()，自定义的挂起方法是有效的
let concurrentQueue = DispatchQueue(label: "concurrent",attributes: .concurrent)

//队列、线程总结，死锁的不是线程，是队列