想象一个屏幕 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在这种场景下如何使用？

最佳答案

您希望一次只能处理一件事，因此您的信号量值应该为 1。鉴于此，您也可以轻松地使用 NSLock。但这里是使用信号量的概要。

当您开始计算时，wait()(无限期地)在信号量上。正如您所建议的，您可以利用 View Controller 生命周期的固有顺序来了解这实际上不会阻塞。每当你完成时，`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

关于ios - 在这个 "starts busy"推测处理场景中使用 DispatchSemaphore，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48024558/