GCD信号量的了解和簡單的應用（異步等待，結合group實作多個任務的并發和依賴）(swift)

1.了解：DispatchSemaphore,就是一個信号量，這個信号量就相當于一個互斥資源，用來控制異步線程之間的互相等待，達到線程鎖的功能，與一般的互斥鎖不同，互斥鎖是鎖住某段代碼或資源，保證資源的安全通路。而信号量以自身為資源，達到控制線程互相依賴關系。

2.應用1：異步任務的等待。建立一個value為0的信号量，當任務執行完成後，通過signal方法增加1，在主線程或者其他地方通過wait函數等待并進入其他任務。

do {
            let queue = DispatchQueue.global()
            let sema = DispatchSemaphore.init(value: 0)
            queue.async {
                //執行異步任務
                sleep(10)
                print("10完成")
                
                sema.signal()
            }
            
            _ = sema.wait(timeout: DispatchTime.distantFuture)
            print("進入主線程下個任務,會卡死主線程")
        }           

3.應用2：通過group 控制多個線程任務之間的依賴關系。

//1.group中控制依賴管理，1，2，3三個異步操作需要完成之後才能重新整理UI，enter 和 leave控制group中所有操作是否完成。
        let queue = DispatchQueue.global()
        let group = DispatchGroup.init()
        queue.async(group: group, execute: DispatchWorkItem.init(block: {

            group.enter()
            queue.async {
                sleep(1)
                print("1 完成")
                group.leave()
            }

            group.enter()
            queue.async {
                sleep(2)
                print("2 完成")
                group.leave()
            }

            group.enter()
            queue.async {
                sleep(3)
                print("3 完成")
                group.leave()
            }

            group.notify(queue: DispatchQueue.main, execute: {
                print("重新整理UI")
            })

        }))           

4.結合group，用信号量控制最大并發數。

do {
            let queue = DispatchQueue.global()
            let group = DispatchGroup.init()
            queue.async(group: group, execute: DispatchWorkItem.init(block: {

                let semaphore = DispatchSemaphore.init(value: 3)//最大并發數是3
                group.enter()
                queue.async {
                    _ = semaphore.wait(timeout: DispatchTime.distantFuture)
                    sleep(1)
                    print("1 完成")
                    group.leave()
                    semaphore.signal()
                }

                group.enter()
                queue.async {
                    _ = semaphore.wait(timeout: DispatchTime.distantFuture)
                    sleep(2)
                    print("2 完成")
                    group.leave()
                    semaphore.signal()
                }

                group.enter()
                queue.async {
                    _ = semaphore.wait(timeout: DispatchTime.distantFuture)
                    sleep(3)
                    print("3 完成")
                    group.leave()
                    semaphore.signal()
                }

                group.notify(queue: DispatchQueue.main, execute: {
                    print("重新整理UI")
                })

            }))
        }