如何在后台线程的同步上下文获取异步函数返回值？

能不能在后台线程的任务外部获取async函数的执行结果？我们可以通过@MainActor在主线程的任务外部获取结果，但我需要在等待async函数结果的后台线程中实现该操作。

参考初始代码：

func asyncFunc() async -> Int {
    // 这里是异步代码
}

// 该函数运行在后台线程
func syncFunc() -> Int {
    let semaphore = DispatchSemaphore(value: 0)
    var value: Int
    Task {
        value = await asyncFunc()       // 报错：“Mutation of captured var 'value' in concurrently-executing code”
        semaphore.signal()
    }
    semaphore.wait()
    return value
}

编译器报错：

Mutation of captured var 'value' in concurrently-executing code.

这个错误原因明确，符合预期。于是尝试用Actor包装value：

actor ValueActor {
    var value = 0
    func setValue(_ newValue: Int) {
        value = newValue
    }
}

// 该函数运行在后台线程
func syncFunc() -> Int {
    let semaphore = DispatchSemaphore(value: 0)
    let valueActor = ValueActor()
    Task {
        let value = await asyncFunc()
        await valueActor.setValue(value)
        semaphore.signal()
    }
    semaphore.wait()
    return valueActor.value             // 报错：“Actor-isolated property 'value' can not be referenced from a non-isolated context”
}

此时报错：

Actor-isolated property 'value' can not be referenced from a non-isolated context

可行的解决方案 #

方案1：使用@unchecked Sendable标记变量

因为我们通过信号量严格保证了变量的访问是串行的（只有异步任务修改完成后，当前后台线程才会读取变量），所以可以安全地用@unchecked Sendable消除编译器的并发访问警告：

func asyncFunc() async -> Int {
    // 模拟异步操作
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    return 42
}

// 运行在后台线程
func syncFunc() -> Int {
    let semaphore = DispatchSemaphore(value: 0)
    @unchecked Sendable var result = 0
    Task {
        result = await asyncFunc()
        semaphore.signal()
    }
    semaphore.wait()
    return result
}

方案2：使用UnsafeMutablePointer

通过指针直接操作变量，绕过编译器的捕获检查，同时依赖信号量保证线程安全：

func syncFunc() -> Int {
    let semaphore = DispatchSemaphore(value: 0)
    var result = 0
    withUnsafeMutablePointer(to: &result) { ptr in
        Task {
            ptr.pointee = await asyncFunc()
            semaphore.signal()
        }
    }
    semaphore.wait()
    return result
}

方案3：将Actor的取值操作也纳入异步任务

如果坚持使用Actor，可以在异步任务中完成取值并传递结果，避免在非隔离上下文访问Actor属性：

actor ValueActor {
    var value = 0
    func setValue(_ newValue: Int) {
        value = newValue
    }
    func getValue() -> Int {
        return value
    }
}

func syncFunc() -> Int {
    let semaphore = DispatchSemaphore(value: 0)
    let valueActor = ValueActor()
    var result = 0
    Task {
        let asyncValue = await asyncFunc()
        await valueActor.setValue(asyncValue)
        result = await valueActor.getValue()
        semaphore.signal()
    }
    semaphore.wait()
    return result
}

注意事项 #

• 这种“同步等待异步任务”的写法要谨慎使用，可能会导致线程阻塞，尤其是在主线程中调用时容易引发死锁，但在后台线程中相对安全。
• 确保异步任务不会依赖当前阻塞的线程，否则会造成死锁。

内容的提问来源于stack exchange，提问作者Vladimir