swift - 如何在 Swift 5.5 中等待来自同步函数的异步函数？

Question

当遵守协议(protocol)或覆盖父类(super class)方法时，您可能无法将方法更改为 async ，但您可能仍想拨打一些 async代码。例如，当我正在重写一个程序以使用 Swift 新的结构化并发编写的程序时，我想调用一些 async通过覆盖 class func setUp() 在我的测试套件开头设置代码定义于 XCTestCase .我希望我的设置代码在任何测试运行之前完成，所以使用 Task.detached或 async { ... }不合适。
最初，我写了一个这样的解决方案:

final class MyTests: XCTestCase {
    override class func setUp() {
        super.setUp()
        unsafeWaitFor {
            try! await doSomeSetup()
        }
    }
}

func unsafeWaitFor(_ f: @escaping () async -> ()) {
    let sema = DispatchSemaphore(value: 0)
    async {
        await f()
        sema.signal()
    }
    sema.wait()
}

这似乎工作得很好。然而，在 Swift concurrency: Behind the scenes ，运行时工程师 Rokhini Prabhu 指出

Primitives like semaphores and condition variables are unsafe to use with Swift concurrency. This is because they hide dependency information from the Swift runtime, but introduce a dependency in execution in your code... This violates the runtime contract of forward progress for threads.

她还包括这样一个不安全的代码模式的代码片段

func updateDatabase(_ asyncUpdateDatabase: @Sendable @escaping () async -> Void) {
    let semaphore = DispatchSemaphore(value: 0)

    async {
        await asyncUpdateDatabase()
        semaphore.signal()
    }

    semaphore.wait()

}

这尤其是我想出的确切模式(我觉得很有趣，我想出的代码正是规范的错误代码模重命名)。
不幸的是，我找不到任何其他方法来等待异步代码从同步函数中完成。此外，我还没有找到任何方法来获取同步函数中异步函数的返回值。我在互联网上找到的唯一解决方案似乎和我的一样不正确，例如这个 The Swift Dev article说

In order to call an async method inside a sync method, you have to use the new detach function and you still have to wait for the async functions to complete using the dispatch APIs.

我认为这是不正确的或至少是不安全的。
等待 async 的正确、安全的方法是什么？同步函数中的函数来处理现有的同步类或协议(protocol)要求，不特定于测试或 XCTest？或者，我在哪里可以找到详细说明 async 之间相互作用的文档/ await在 Swift 和现有的同步原语中，如 DispatchSemaphore ?它们永远不会安全，或者我可以在特殊情况下使用它们吗？
更新:
根据@TallChuck 的回答，注意到 setUp()总是在主线程上运行，我发现我可以通过调用任何 @MainActor 故意死锁我的程序。功能。这是我的解决方法应尽快更换的极好证据。
明确地，这是一个挂起的测试。

import XCTest
@testable import Test

final class TestTests: XCTestCase {
    func testExample() throws {}
    
    override class func setUp() {
        super.setUp()
        unsafeWaitFor {
            try! await doSomeSetup()
        }
    }
}

func doSomeSetup() async throws {
    print("Starting setup...")
    await doSomeSubWork()
    print("Finished setup!")
}

@MainActor
func doSomeSubWork() {
    print("Doing work...")
}

func unsafeWaitFor(_ f: @escaping () async -> ()) {
    let sema = DispatchSemaphore(value: 0)
    async {
        await f()
        sema.signal()
    }
    sema.wait()
}

但是，如果 @MainActor，它不会挂起被注释掉了。我担心的一个问题是，如果我调用库代码(Apple 的或其他的)，则无法知道它最终是否会调用 @MainActor。即使函数本身没有标记 @MainActor .
我的第二个恐惧是即使没有 @MainActor ，我仍然不知道我保证这是安全的。在我的电脑上，这挂起。

import XCTest
@testable import Test

final class TestTests: XCTestCase {
    func testExample() throws {}
    
    override class func setUp() {
        super.setUp()
        unsafeWaitFor {
            unsafeWaitFor {
                unsafeWaitFor {
                    unsafeWaitFor {
                        unsafeWaitFor {
                            unsafeWaitFor {
                                print("Hello")
                            }
                        }
                    }
                }
            }
        }
    }
}
func unsafeWaitFor(_ f: @escaping () async -> ()) {
    let sema = DispatchSemaphore(value: 0)
    async {
        await f()
        sema.signal()
    }
    sema.wait()
}

如果这不适合您，请尝试添加更多 unsafeWaitFor s。我的开发 VM 有 5 个内核，这是 6 unsafeWaitFor s。 5 对我来说很好用。这明显不同于 GCD。这是 GCD 中的等效项，它不会卡在我的机器上。

final class TestTests: XCTestCase {
    func testExample() throws {}
    
    override class func setUp() {
        super.setUp()
        safeWaitFor { callback in
            safeWaitFor { callback in
                safeWaitFor { callback in
                    safeWaitFor { callback in
                        safeWaitFor { callback in
                            safeWaitFor { callback in
                                print("Hello")
                                callback()
                            }
                            callback()
                        }
                        callback()
                    }
                    callback()
                }
                callback()
            }
            callback()
        }
    }
}
func safeWaitFor(_ f: @escaping (() -> ()) -> ()) {
    let sema = DispatchSemaphore(value: 0)
    DispatchQueue(label: UUID().uuidString).async {
        f({ sema.signal() })
    }
    sema.wait()
}

这很好，因为 GCD 很乐意生成比 CPU 多的线程。所以也许建议是“只使用与 CPU 一样多的 unsafeWaitFor”，但如果是这种情况，我希望看到苹果在某处明确说明了这一点。在一个更复杂的程序中，我真的可以确定我的代码可以访问机器上的所有内核，或者我的程序的其他部分是否可能正在使用其他内核，因此 unsafeWaitFor 请求的工作|永远不会被安排？
当然，我的问题中的示例是关于测试的，因此在这种情况下，很容易说“建议是什么并不重要:如果有效，则有效，如果无效，则测试失败，你会修复它，”但我的问题不仅仅是关于测试；那只是一个例子。
使用 GCD，我对同步异步代码与信号量(我自己控制的 DispatchQueue s，而不是主线程)的能力充满信心，而不会耗尽所有可用线程。我希望能够同步 async来自同步函数的代码 async/ await在 Swift 5.5 中。
如果这样的事情是不可能的，我也会接受 Apple 的文档，详细说明我可以安全使用的情况 unsafeWaitFor或类似的同步技术。

Answer 1

您可能会争辩说异步代码不属于 setUp() ，但在我看来，这样做会将同步性与顺序性......冰性混为一谈？ setUp()点是在其他任何东西开始运行之前运行，但这并不意味着它必须同步编写，只是其他一切都需要将其视为依赖项。
幸运的是，Swift 5.5 引入了一种处理代码块之间依赖关系的新方法。它被称为 await关键字(也许你听说过)。关于async最迷惑的事情/await (在我看来)是它造成的双面鸡和蛋问题，在我能找到的任何 Material 中都没有很好地解决这个问题。一方面，您只能在已经异步的代码中运行异步代码(即使用 await )，另一方面，异步代码似乎被定义为使用 await 的任何东西。 (即运行其他异步代码)。
在最低级别，最终必须有一个 async实际执行异步操作的函数。从概念上讲，它可能看起来像这样(请注意，虽然以 Swift 代码的形式编写，但这是严格的伪代码):

func read(from socket: NonBlockingSocket) async -> Data {
    while !socket.readable {
        yieldToScheduler()
    }

    return socket.read()
}

换句话说，与鸡和蛋的定义相反，这个异步函数不是通过使用 await 来定义的。陈述。它会循环直到数据可用，但它允许自己在等待时被抢占。
在最高级别，我们需要能够启动异步代码而无需等待它终止。每个系统都以单个线程开始，并且必须通过某种引导过程来产生任何必要的工作线程。在大多数应用程序中，无论是在台式机、智能手机、Web 服务器上还是在您拥有的任何设备上，主线程然后进入某种“无限”循环，在那里它可能会处理用户事件或监听传入的网络连接，然后以适当的方式与 worker 互动。然而，在某些情况下，程序是要运行到完成的，这意味着主线程需要监督每个工作程序的成功完成。使用传统线程，例如 POSIX pthread库，主线程调用 pthread_join()对于某个线程，该线程在该线程终止之前不会返回。使用 Swift 并发性，您..... 不能做这样的事情(据我所知)。
structured concurrency提议允许顶级代码调用 async函数，或者直接使用 await关键字，或者用 @main 标记一个类，并定义一个 static func main() async成员函数。在这两种情况下，这似乎都意味着运行时创建了一个“主”线程，将您的顶级代码作为工作线程启动，然后调用某种 join()。函数等待它完成。
如您的代码片段所示，Swift 确实提供了一些标准库函数，允许同步代码创建 Task s。任务是 Swift 并发模型的构建块。您引用的 WWDC 演示文稿解释说，运行时旨在创建与 CPU 内核数量一样多的工作线程。然而，稍后，他们展示了下图，并解释了在主线程需要运行的任何时候都需要上下文切换。

据我了解，线程到 CPU 内核的映射仅适用于“协作线程池”，这意味着如果您的 CPU 有 4 个内核，则实际上总共有 5 个线程。主线程主要是保持阻塞状态，因此唯一的上下文切换将是主线程唤醒的极少数情况。
重要的是要理解，在这种基于任务的模型下，是运行时而不是操作系统控制“继续”切换(与上下文切换不同)。另一方面，信号量在操作系统级别运行，对运行时不可见。如果您尝试使用信号量在两个任务之间进行通信，则可能会导致操作系统阻塞您的线程之一。由于运行时无法跟踪这一点，因此它不会启动一个新线程来代替它，因此充其量您最终会未得到充分利用，最坏的情况是死锁。
好的，终于，在 Meet async/await in Swift ，说明 XCTest库可以“开箱即用”运行异步代码。但是，不清楚这是否适用于 setUp() ，或仅适用于单个测试用例函数。如果事实证明它确实支持异步 setUp()函数，那么你的问题突然就完全无趣了。另一方面，如果它不支持它，那么你就陷入了不能直接等待你的 async的位置。功能，但仅仅启动一个非结构化的 Task 也不够好(即您触发并忘记的任务)。
您的解决方案(我认为这是一种解决方法 - 正确的解决方案是让 XCTest 支持 async setUp() )，仅阻止主线程，因此应该可以安全使用。