在这个“开始繁忙”的推测处理场景中使用DispatchSemaphore

Question

想象一下屏幕S.用户到达S，看看东西。有一个按钮B ......

|    |
|   B|
|    |
|    |

当你按B ..

func clickedB() {

   blockingSpinner = true
   longCalculation()
   blockingSpinner = false
   showResult()
}

func longCalculation() {

   // a few seconds
}

（我们希望用户只是等待，看看模态微调器，如果/正在进行计算。）

通常，当用户到达屏幕S时，他们在触摸B之前会看几秒钟。

所以......

var waitor = DispatchSemaphore(value: 0) // or ???

func viewDidLoad() {

   DispatchQueue.global(qos: .background).async { longCalculation() }
}
func longCalculation() {

   something waitor
   do the calculation
   something waitor
   DispatchQueue.main.async {
     something waitor
   }
}
func clickedB() {

   // (note that ...   calculation may have finished ages ago
   // or we may be in the middle of it, it has a second or so remaining
   // or perhaps even this is the second+ time the user has clicked B)
   something waitor
   if/while longCalculation is still running,
       blockingSpinner = true
   blockingSpinner = false
   showResult()
}

我担心我不知道在这种情况下如何使用DispatchSemaphore。

他们使wait()和signal()工作的特殊方式似乎没有在这里加起来。

如何在这种情况下使用DispatchSemaphore？

Answer 1

你想要一次只能做一件事，所以你的信号量应该是1.鉴于此，你也可以像使用NSLock一样容易。但这是使用信号量的大纲。

当你开始计算时，wait()（无限期地）在信号量上。正如您所建议的那样，您可以利用视图控制器生命周期的固有顺序来了解这实际上不会阻塞。每当你完成时，`signal（）。显然这应该都是在后台完成的，这样主线程就不会被阻塞。

处理按钮时，通过瞬间超时“等待”测试信号量，如果得到.timedOut，则显示微调器。我们可以在主线程上执行此操作，因为信号量是可用还是超时，将没有实际的等待时间。请注意，此处不需要信号：如果等待超时，信号量将自动重新递增。如果等待成功，则作业完成 - 直接继续显示结果。

如果没有完成工作，你就会显示微调器;现在在后台等待（无限期）。当等待结束时 - 因为信号量已发出信号 - 跳回主线程，关闭微调器并显示结果。

此时，信号量的计数为0，因此如果您需要再次通过此代码路径，则必须发信号通知信号量。

基本上，填写你做的代码草图：

class WhateverViewController : UIViewController
{
    private let semaphore = DispatchSemaphore(value: 1)

    override func viewDidLoad()
    {
        super.viewDidLoad()
        self.performLongCalculation()
    }

    private func performLongCalculation()
    {
        DispatchQueue.global(qos: .background).async {
            self.semaphore.wait()
            // Synchronous processing...
            self.semaphore.signal()
        }
    }

    private func buttonTapped()
    {
        if self.semaphore.isBusy {
            self.waitForResult()
        }
        else {
            self.showResult()
        }
    }

    private func buttonTappedAlternative()
    {
        // Show the spinner unconditionally, if you assume that the
        // calculation isn't already done.
        self.waitForResult()
    }

    private func waitForResult()
    {
        self.showSpinner()
        DispatchQueue.global(qos: .userInitiated).async {
            self.semaphore.wait()
            DispatchQueue.main.async {
                self.dismissSpinner()
                self.showResult()
            }
        }
    }

    private func showResult()
    {
        // Put stuff on screen
        self.semaphore.signal()
    }
}

buttonTapped在DispatchSemaphore上使用便利的地方

extension DispatchSemaphore
{
    var isBusy : Bool { return self.wait(timeout: .now()) == .timedOut }
}

如果你愿意，你可以改变这种逻辑：isIdle就是self.wait(timeout: .now()) == .success