IOS - DispatchQueue.main.asyncAfter(deadline: .now()) 和 perform(_:with:afterDelay:) 之间的区别，延迟为 0

Question

我意识到当主队列“忙”时使用DispatchQueue.main.asyncAfter(deadline: .now()) 和perform(_:with:afterDelay:0) 是有区别的。

请注意，在我的情况下，perform(_:with:afterDelay:) 是从主队列调用的。

似乎DispatchQueue.main.asyncAfter(deadline: .now()) 在下一个运行循环中立即执行任务而不关心主队列，但延迟为 0 的 perform(_:with:afterDelay:) 将等待并仅在主队列“空闲”时执行任务（也许不会在下一个运行循环中调用）。

根据perform(_:with:afterDelay:)的Apple文档

指定延迟为 0 并不一定会导致选择器立即执行。选择器仍在线程的运行循环中排队并尽快执行。

我不确定我是否正确理解它们，所以谁能帮我解释一下它们之间的本质区别是什么？ 尽快执行是什么意思？

我发现了同样的问题here，但似乎不是我想要的。

Answer 1

我创建了这个独立测试来探索这个主题。

class ViewController: UIViewController {

    @objc func test1(_ info: Any) {
        guard let str = info as? String else { return }
        sleep(1)
        print(str)

        if str != "selector 3" {
            self.perform(#selector(test1), with: "selector 3", afterDelay: 0)
        }

        DispatchQueue.main.asyncAfter(deadline: .now()) {
            sleep(1)
            print("dispatch 4 queued by \(str)")
        }

    }


    @IBAction func test(_ sender: UIButton) {
        print("begin test")

        self.perform(#selector(test1), with: "selector 1", afterDelay: 0)

        DispatchQueue.main.asyncAfter(deadline: .now()) {
            DispatchQueue.main.asyncAfter(deadline: .now()) {
                sleep(1)
                print("dispatch 3")
            }
            sleep(1)
            print("dispatch 1")
        }

        self.perform(#selector(test1), with: "selector 2", afterDelay: 0)

        DispatchQueue.main.asyncAfter(deadline: .now()) {
            sleep(1)
            print("dispatch 2")
        }

        print("end test")
    }

}

结果输出：

begin test
end test
dispatch 1
dispatch 2
selector 1
selector 2
dispatch 3
dispatch 4 queued by selector 1
dispatch 4 queued by selector 2
selector 3
selector 3
dispatch 4 queued by selector 3
dispatch 4 queued by selector 3

---

注意事项：

1. begin test 和 end test 在显示 perform(_:with:afterDelay:) 和 DispatchQueue.main.asyncAfter 已排队并稍后运行的任何其他输出之前打印。
2. 前两个DispatchQueues 在performs 之前运行，即使它们的排队顺序不同。
3. 所有打印都相隔一秒，这意味着它们都在同一个队列上运行，等待前一个完成。
4. dispatch 3 不会跳到 selector 1 和 selector 2 前面，即使它在 dispatch 1 打印之前排队。

---

结论：

1. Dispatch.main.asyncAfter 和perform(_:with:afterDelay:) 都将它们的选择器/闭包排队等待稍后执行。由于您在主线程上运行 perform(_:with:afterDelay:)，因此它使用主队列进行调度。
2. 由于某些未知（对我而言）原因，当在同一运行循环中排队时，Dispatch.main.asyncAfter(0) 呼叫在 perform(_:with:afterDelay:0) 呼叫之前排队。注意：如果有任何延迟被添加到Dispatch.main.asyncAfter，它将在perform(_:with:afterDelay:) 之后排队。例如，尝试使用.now() + .milliseconds(1)。
3. 尽快执行只是表示它们已排队并按队列顺序处理的另一种方式。根据任务在队列中占用多长时间，最终处理任务之前可能需要多次运行运行循环。