我正在用Swift桥接同步/异步世界，并进行渐进式采用异步/等待。我正在尝试从非异步函数调用返回值的异步函数。我理解明确使用Task是这样做的方式，例如在这里所述。
示例并不真正适合，因为该任务没有返回值。
经过多番搜索，我仍然找不到任何描述我认为是相当常见的请求：同步调用异步任务（是的，我明白那可能会冻结主线程）。
理论上，我想在我的同步函数中编写如下内容：
let x = Task {
return await someAsyncFunction()
}.result
然而，当我尝试这样做时，由于尝试访问result，我得到了这个编译器错误：
'async'属性在不支持并发的函数中进行访问
我找到的一个替代方法是类似于：
Task.init {
self.myResult = await someAsyncFunction()
}
myResult必须作为@State成员变量来归属。
然而，这并不是我想要的方式，因为在Task.init()完成并移到下一个语句之前，无法保证完成该任务。那么，我该如何同步等待该任务完成？
您不应该同步等待异步任务。
可能有人会提出类似于以下的解决方案：
func updateDatabase(_ asyncUpdateDatabase: @Sendable @escaping () async -> Void) {
let semaphore = DispatchSemaphore(value: 0)
Task {
await asyncUpdateDatabase()
semaphore.signal()
}
semaphore.wait()
}
尽管在某些简单条件下可以使用，但根据WWDC 2021 Swift Concurrency: Behind the scenes，这是不安全的。原因在于系统期望您遵守运行时合同。该合同要求：
线程始终能够向前推进。
这意味着线程永远不会被阻塞。当异步函数到达挂起点（例如await表达式）时，函数可以被挂起，但线程不会被阻塞，而是可以进行其他工作。基于此合同，新的协作线程池只能生成与CPU核心数量相同的线程，避免过多的线程上下文切换。这也是演员不会导致死锁的关键原因。
以上的信号量模式违反了这个合同。semaphore.wait()函数会阻塞线程。这可能会引起问题。例如：
func testGroup() {
Task {
await withTaskGroup(of: Void.self) { group in
for _ in 0 ..< 100 {
group.addTask {
syncFunc()
}
}
}
NSLog("Complete")
}
}
func syncFunc() {
let semaphore = DispatchSemaphore(value: 0)
Task {
try? await Task.sleep(nanoseconds: 1_000_000_000)
semaphore.signal()
}
semaphore.wait()
}
在testGroup函数中，我们添加了100个并发的子任务，但不幸的是，任务组永远无法完成。在我的 Mac 上，系统会生成 4 个协同线程，只需添加 4 个子任务就足以无限期地阻塞所有 4 个线程。这是因为，在所有 4 个线程都被wait函数阻塞之后，没有更多的线程可用于执行内部任务来发出信号量。
另一个不安全使用的例子是 actor 死锁：
func testActor() {
Task {
let d = Database()
await d.updateSettings()
NSLog("Complete")
}
}
func updateDatabase(_ asyncUpdateDatabase: @Sendable @escaping () async -> Void) {
let semaphore = DispatchSemaphore(value: 0)
Task {
await asyncUpdateDatabase()
semaphore.signal()
}
semaphore.wait()
}
actor Database {
func updateSettings() {
updateDatabase {
await self.updateUser()
}
}
func updateUser() {
}
}
在这里调用updateSettings函数将会死锁。因为它会同步等待updateUser函数完成，而updateUser函数被隔离到同一个actor中，所以它也在等待updateSettings函数先完成。
以上两个示例使用了DispatchSemaphore。基于类似的原因，在NSCondition中以类似的方式进行等待是不安全的。基本上，同步等待意味着阻塞当前线程。除非您只想要临时解决方案并完全理解风险，否则避免使用此模式。
NSFileCoordinator().coordinate，并使用async/await进行封装，但我还在其中加入了withTaskCancellationHandler以支持任务取消。 - malhal除了使用信号量，你还可以像这里一样将异步任务封装在操作中。一旦底层异步任务完成，您可以发出操作完成的信号，并使用waitUntilFinished()等待操作完成：
let op = TaskOperation {
try await Task.sleep(nanoseconds: 1_000_000_000)
}
op.waitUntilFinished()
semaphore.wait() 或 op.waitUntilFinished() 的过程中，会阻塞当前线程，而阻塞线程可能会导致现代并发性能下的未定义运行时行为。 如果您打算仅在不使用现代并发性能的上下文中使用此方法，则可以在 Swift 5.7 中提供属性标记方法在异步上下文中不可用：@available(*, noasync, message: "this method blocks thread use the async version instead")
func yourBlockingFunc() {
// do work that can block thread
}
通过使用这个属性，你只能在非异步上下文中调用这个方法。但是需要注意的是，如果那个方法没有指定noasync可用性，你可以从异步上下文中调用调用此方法的非异步方法。
let result = runBlocking {
try? await Task.sleep(nanoseconds: 1_000_000_000)
return "Some result"
}
print(result) // prints "Some result"
Task.synchronous将一个异步调用包装在同步上下文中，并像这样使用它：Task.synchronous { try await myAsyncFunc() }
extension Task where Failure == Error {
/// Performs an async task in a sync context.
///
/// - Note: This function blocks the thread until the given operation is finished. The caller is responsible for managing multithreading.
static func synchronous(priority: TaskPriority? = nil, operation: @escaping @Sendable () async throws -> Success) {
let semaphore = DispatchSemaphore(value: 0)
Task(priority: priority) {
defer { semaphore.signal() }
return try await operation()
}
semaphore.wait()
}
}
func synchronousContext() { // No `async` keyword here
let duration: UInt64 = 2_000_000_000 /* 2 seconds */
var seconds: UInt64 { duration/1_000_000_000 }
print("Start: Should wait for \(seconds) seconds...")
Task.synchronous { try await Task.sleep(nanoseconds: duration) } // No `await` keyword for calling the `Task.synchronous `
print("...Ended after \(seconds) seconds")
}
我也一直在思考这个问题。例如，如何在主线程中启动一个任务（或多个任务）并等待它们完成？这可能是C++的思维方式，但在Swift中肯定也有方法可以实现。不管好坏，我想到了使用全局变量来检查工作是否完成：
import Foundation
var isDone = false
func printIt() async {
try! await Task.sleep(nanoseconds: 200000000)
print("hello world")
isDone = true
}
Task {
await printIt()
}
while !isDone {
Thread.sleep(forTimeInterval: 0.1)
}
sleep()。如果需要等待某个事件发生，请使用运行循环函数。 - Cristik
Task.init闭包内呢？话虽如此，我认为上述建议是很好的。 - jnpdx