Ios 为什么在Actor内部使用withTaskGroupwork并行运行

考虑您的第一个示例:

actor Actor1 {
    func performAsyncTasks() async {
        async let _ = asyncTasks1() // this not running in parallel
        async let _ = asyncTasks2() // this not running in parallel
    }
    
    func asyncTasks1() async {
        for i in 1...10_000_0 {
            print("In Task 1: \(i)")
        }
    }
    
    func asyncTasks2() async {
        for i in 1...10_000_0 {
            print("In Task 2: \(i)")
        }
    }
}

你说过:

我们可以看到，应该并行完成的async let个工作是在Actor1中按顺序完成的

是的，通常async let可以让 routine 并发运行.但这不会在这里发生，因为这两个功能都独立于同一个参与者，并且没有await个停止点.

有人说:

如果async let是let _ = await asyncTasks1()…的缩写

但事实并非如此.请参见SE-0317.

如果你想看到并行执行，你可以使用async let.您只需要使用非隔离函数:

actor Foo {
    func performAsyncTasks() async {
        async let value1 = asyncTasks1() // this IS running in parallel
        async let value2 = asyncTasks2() // this IS running in parallel
        let total = await value1 + value2
        print(total)
    }

    nonisolated func asyncTasks1() async -> Int {
        await poi.interval(name: #function) {
            var value = 0
            for _ in 1...1_000_000_000 {
                value += 1
            }
            return value
        }
    }

    nonisolated func asyncTasks2() async -> Int {
        await poi.interval(name: #function) {
            var value = 0
            for _ in 1...1_000_000_000 {
                value += 1
            }
            return value
        }
    }
}

如果我在仪器中分析它，我可以看到它们是并行运行的:

顺便说一句，上面使用了以下POI实用程序函数:

import os.log

let poi = OSLog(subsystem: "Test", category: .pointsOfInterest)

extension OSLog {
    func interval<T: Sendable>(name: StaticString, block: () async throws -> T) async rethrows -> T {
        let id = OSSignpostID(log: self)
        os_signpost(.begin, log: self, name: name, signpostID: id)
        defer { os_signpost(.end, log: self, name: name, signpostID: id) }
        return try await block()
    }
}