swift - 一次多次调用 DispatchSemaphore 的 wait() 是否安全？

Question

我得到了三个分派(dispatch)线程，名为 queueA、queueB、queueC。
现在我希望在 queueB 和 queueC 完成后执行 queueA。
所以我尝试通过DispatchSemaphore来实现它。
我的问题是:
在一个线程中一次调用两次 wait() 以使信号量为 2 是否安全？

 self.semaphore.wait()  // -1
 self.semaphore.wait()  // -1

以下是完整的测试代码:

class GCDLockTest {
    let semaphore = DispatchSemaphore(value: 0) 
   
    func test() {
        
        let queueA = DispatchQueue(label: "Q1")
        let queueB = DispatchQueue(label: "Q2")
        let queueC = DispatchQueue(label: "Q3")
        queueA.async {
            self.semaphore.wait()  // -1
            self.semaphore.wait()  // -1
            print("QueueA gonna sleep")
            sleep(3)
            print("QueueA woke up")                
        }
        queueB.async {
            self.semaphore.signal()  // +1
            print("QueueB gonna sleep")
            sleep(3)
            print("QueueB woke up")

        }
        queueC.async {
            self.semaphore.signal()  // +1
            print("QueueC gonna sleep")
            sleep(3)
            print("QueueC wake up")

        }
    }
}

Answer 1

首先，稍微迂腐地说，signal 递增信号量，wait 递减信号量(除非它为零，在这种情况下它会等待).

Is this safe to call wait() two times in a thread at one time to make the semaphore 2 [sic]?

信号量操作保证是线程安全的，否则没有意义，所以您正在做的事情会正常进行。您确实可以两次调用 wait 以在概念上两次获取资源。

但是，您有一个正在阻塞的后台线程。这是一件坏事，因为用于在调度队列上执行 block 的线程不会在需要时创建，它们是从一个池中分配的，该池的大小根据各种因素(如处理器核心数量)而定。您在队列 A 上的 block 将占用一个线程，直到队列 B 和队列 C 线程都向信号量发出信号。

最坏的情况发生在您进入函数 test() 时线程池中只剩下一个线程。如果队列 A 上的 block 在其他两个 block 中的任何一个之前获取它，就会出现死锁，因为 A 将等待信号量，而 B 和 C 将等待 A 完成以便它们可以拥有一个线程。

最好在其他两个线程准备好启动 A 之前不要启动它。这可以通过在适当的时间在主线程上执行一个 block 来完成。像这样:

class GCDLockTest {
    var cFinished = false
    var bFinished = false 

    func test() {

        let queueA = DispatchQueue(label: "Q1")
        let queueB = DispatchQueue(label: "Q2")
        let queueC = DispatchQueue(label: "Q3")
        queueB.async {
             DispatchQueue.main.async
             {
                 bFinished = true
                 if cFinished
                 {
                     queueA.async {
                         print("QueueA gonna sleep")
                         sleep(3)
                         print("QueueA woke up")                
                     }
                 }
             }
            print("QueueB gonna sleep")
            sleep(3)
            print("QueueB woke up")

        }
        queueC.async {
             DispatchQueue.main.async
             {
                 cFinished = true
                 if bFinished
                 {
                     queueA.async {
                         print("QueueA gonna sleep")
                         sleep(3)
                         print("QueueA woke up")                
                     }
                 }
             }
            print("QueueC gonna sleep")
            sleep(3)
            print("QueueC wake up")

        }
    }
}

在上面，您不需要任何信号量或其他同步，因为所有同步工作都是在串行的主队列上完成的。即启动 A 的两个 block 永远不能同时运行。

这是一种方法，但 Apple 提供了 dispatch groups正是你的问题。使用调度组，您可以将 B 和 C 添加到组中，并让他们在准备好 A 开始时通知组。

class GCDLockTest {

    func test() {

        let group = DispatchGroup()

        let queueA = DispatchQueue(label: "Q1")
        let queueB = DispatchQueue(label: "Q2")
        let queueC = DispatchQueue(label: "Q3")
        group.enter()
        queueB.async {
            group.leave()
            print("QueueB gonna sleep")
            sleep(3)
            print("QueueB woke up")

        }
        group.enter()
        queueC.async {
            group.leave()
            print("QueueC gonna sleep")
            sleep(3)
            print("QueueC wake up")

        }
        group.notify(queue: queueA) {
            print("QueueA gonna sleep")
            sleep(3)
            print("QueueA woke up")                
    }
}

在开始 B 和 C 之前，先进入组。然后在启动 B 和 C 之后，我们在组中放置一个通知 block ，以便当他们都离开组时，在正确的队列中启动 A 的 block 。

另见 https://developer.apple.com/documentation/dispatch/dispatchgroup