swift GCD常用方法记录一下

创建DispatchQueue

// 与当前进程的主线程相关联的调度队列, 即主队列。
class var main: DispatchQueue { get }

// 返回一个系统全局队列
class func global(qos: DispatchQoS.QoSClass = .default) -> DispatchQueue

/**
* 创建一个派发队列。
* label：队列的唯一标识。
* qos  ：决定了系统安排任务执行的优先级。
* attributes ： 执行队列的执行方式，串行还是并行。
* autoreleaseFrequency ： 指示队列自动释放对象的频率的常量。
* target ： 计划执行blocks的目标队列。如果希望系统提供适合当前对象的队列，请指定DISPATCH_TARGET_QUEUE_DEFAULT。
*/
convenience init(label: String, qos: DispatchQoS = .unspecified, attributes: DispatchQueue.Attributes = [], autoreleaseFrequency: DispatchQueue.AutoreleaseFrequency = .inherit, target: DispatchQueue? = nil)

// 获取主队列
let mainQueue = DispatchQueue.main
// 获取全局队列
let globalQueue = DispatchQueue.global()
// 自定义一个并行队列
let customConcurrentQueue = DispatchQueue(label: "com.queue.concurrent", qos: .unspecified, attributes: [.concurrent], autoreleaseFrequency: .inherit, target: nil)
// 自定义一个串行队列，attributes不赋值即是串行。
let serialConcurrentQueue = DispatchQueue(label: "com.queue.serial", qos: .unspecified, attributes: [], autoreleaseFrequency: .inherit, target: nil)
print("mainQueue is \(mainQueue)")
print("globalQueue is \(globalQueue)")
print("customConcurrentQueue is \(customConcurrentQueue)")
print("serialConcurrentQueue is \(serialConcurrentQueue)")

输出结果：
mainQueue is <OS_dispatch_queue_main: com.apple.main-thread>
globalQueue is <OS_dispatch_queue_global: com.apple.root.default-qos>
customConcurrentQueue is <OS_dispatch_queue_concurrent: com.queue.concurrent>
serialConcurrentQueue is <OS_dispatch_queue_serial: com.queue.serial>

//异步执行任务主要有以下这些方法:
//wallDeadline 和 deadline，当系统睡眠后,wallDeadline会继续，但是deadline会被挂起。例如：设置参数为60分钟，当系统睡眠50分钟，wallDeadline会在系统醒来之后10分钟执行，而deadline会在系统醒来之后60分钟执行。
// 立即执行派发的任务，并立即return。
func async(execute: DispatchWorkItem)
// 在指定的时间执行派发的任务，并立即return。
func asyncAfter(deadline: DispatchTime, execute: DispatchWorkItem)
// 在指定的时间执行派发的任务的block，并立即return。
func asyncAfter(deadline: DispatchTime, qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], execute work: @escaping @convention(block) () -> Void)
// 在指定的时间后执行派发的任务，并立即return。
func asyncAfter(wallDeadline: DispatchWallTime, execute: DispatchWorkItem)
// 在指定的时间后执行派发的任务的block，并立即return。
func asyncAfter(wallDeadline: DispatchWallTime, qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], execute work: @escaping @convention(block) () -> Void)

同步任务+串行队列

(没有开启新线程，串行执行任务，当前线程(主线程)中运行)

     let queue1 = DispatchQueue(label: "queue")
     print("begin")
     queue1.sync {
         print("线程1运行")
     }
     queue1.sync {
         print("线程2运行")
     }
     print("end")
     /*
      begin
      线程1运行
      线程2运行
      end
      */

同步任务+并发队列

(没有开启新线程，串行执行任务，当前线程(主线程)中运行)

       let queue2 = DispatchQueue(label: "queue1", attributes: .concurrent)
       print("begin")
       queue2.sync {
           print("线程1运行")
       }
       queue2.sync {
           print("线程2运行")
       }
       print("end")
       /*
        begin
        线程1运行
        线程2运行
        end
        */

异步任务+串行队列

(开启1条新线程，串行执行任务，开启1条新线程中运行)

        let queue3 = DispatchQueue(label: "queue")
        print("begin")
        queue3.async {
            print("线程1运行")
        }
        queue3.async {
            print("线程2运行")
        }
        print("end")
        /*
         begin
         end
         线程1运行
         线程2运行
         */

异步任务+并发队列

(开启2条新线程，并发执行任务，2条新线程中运行)

        let queue4 = DispatchQueue(label: "queue1", attributes: .concurrent)
        print("begin")
        queue4.async {
            print("线程1运行")
        }
        queue4.async {
            print("线程2运行")
        }
        print("end")
        /*
         begin
         end
         线程1运行
         线程2运行
         */

项目中用到的

        //1.延迟执行
        //DispatchTime.now() 获取当前时间
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 3) {
            //需要进行的操作
        }
        //2.异步进行耗时操作,主线程进行用户交互以及刷新UI的操作
        //开启一个全局的异步队列
        DispatchQueue.global().async {
            //耗时操作
            DispatchQueue.main.async {
                //进行UI刷新和用户交互
            }
        }
        //3.处理多数据请求,所有请求完毕进行UI更新
        //创建工作组
        let workingGroup = DispatchGroup()

        //创建队列
        let workingQueue = DispatchQueue(label: "requestData", attributes: .concurrent)

        //第一个网络请求
        workingGroup.enter()
        workingQueue.async {
            //进行数据请求1
            workingGroup.leave()
        }
        //第二个网络请求
        workingGroup.enter()
        workingQueue.async {
            //进行数据请求2
            workingGroup.leave()
        }
        //请求完毕
        workingGroup.notify(queue: .main) {
            //进行UI的更新
        }

信号量

相当于一把锁，信号量为0则阻塞线程，大于0则不会阻塞。则我们通过改变信号量的值，来控制是否阻塞线程，从而达到线程同步

// 创建一个信号，value：信号量
    let semaphore = DispatchSemaphore.init(value: <#T##Int#>)
    // 某个信号进行等待或等待降低信号量,只有当信号量大于0时才会停止等待，继续向下执行
    semaphore.wait()
    // 使某个信号的信号量+1
    semaphore.signal()

func semaphore_demo() {
    let queue = DispatchQueue.global()
    //创建信号量  值为1  意思是最大并发数为1，任务只能一个接一个执行
    let semaphore = DispatchSemaphore.init(value: 1)
    
    //此时信号量为1，无需等待，向下执行 信号量 1->0
    semaphore.wait()
    queue.asyncAfter(deadline: .now() + 4) {
        print("1111")
        //延迟4秒后输出1111，释放信号量，信号量 从0->1
        semaphore.signal()
    }
    
    //延迟4秒输出1111后，此时信号量为1，继续向下执行  同上操作。。。
    semaphore.wait()
    queue.asyncAfter(deadline: .now() + 10) {
        print("2222")
        semaphore.signal()
    }
    
    semaphore.wait()
    queue.asyncAfter(deadline: .now() + 2) {
        print("3333")
        semaphore.signal()
    }
    
    semaphore.wait()
    queue.asyncAfter(deadline: .now() + 1) {
        print("4444")
        semaphore.signal()
    }
    
    semaphore.wait()
    queue.asyncAfter(deadline: .now() + 6) {
        print("5555")
        semaphore.signal()
    }
    
    semaphore.wait()
    print("任务全部完成")
    semaphore.signal()
}

输出

1111
2222
3333
4444
5555
任务全部完成