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（）。显然，这应该都是在后台完成的，这样就不会阻塞主线程。

处理按钮时，按＆＃34;等待＆＃34;测试信号量。在它上面有一个瞬时超时，并显示微调器，如果你得到.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

在这个“开始忙碌”的推测处理场景

1 个答案: