Swift concurrency: 为什么这个方法是异步的？

Question

我正在努力思考如何将 Swift 并发与使用基于块的东西（如 Timer）的旧代码集成。 因此，当我构建下面的代码时，编译器在self.handleTimer()行告诉我Expression is 'async' but is not marked with 'await'

为什么它是异步的？ 它没有标记为async ，也没有做任何事情。 当我在没有计时器的情况下调用它时，我不需要await 。 参与者隔离是否意味着对成员的每次调用都是来自该上下文之外的“异步”？

@MainActor
class MyClass {
    
    func startTimer() {
        _ = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { timer in
            Task {
                self.handleTimer() // "Expression is 'async' but is not marked with 'await'"
            }
        }
    }
    
    func handleTimer() {
    }
}

Answer 1

参与者隔离是否意味着对成员的每次调用都是来自该上下文之外的“异步”？

是的。

您可以通过告诉任务在主要参与者上完成它的工作来删除警告，如下所示：

Task { @MainActor in
    self.handleTimer()
}

或者通过将handleTimer()标记为nonisolated ，如果它没有会破坏 actor 隔离的副作用。

Answer 2

这是因为@MainActor （仅用于更新 UI）如果您使用actor而不是class ，您会得到相同的效果。

actor MyClass {

Actor 是孤立的、并发的部分

Actor 一次只允许一个任务访问其可变状态

这意味着如果其他东西正在改变actor ，那么在handleTimer中完成的任何事情都将被“暂停”。

如果handleTimer不会改变 actor 内部的任何内容，您可以添加nonisolated关键字。

@MainActor
class MyClass {
    
    func startTimer() {
        _ = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { timer in
            Task {
                self.handleTimer() 
            }
        }
    }
    
    nonisolated func handleTimer() {
    }
}

但是闭包中的Task本身就是一个问题。 并发性就是组织和了解任何时候发生的事情。 那个Task打破了它，它被调用然后它就留在那里。 无法停止它或跟踪它何时完成或何时失败。

我建议重新考虑您的设置，以便它使用纯并发设置，闭包和并发充满问题和漏洞。

@MainActor
class MyClass {
    func startTimer(withTimeInterval interval: TimeInterval, upperLimit: Int = .max) async throws {
        for _ in 0...upperLimit{
            try await Task.sleep(for: .seconds(interval))
            handleTimer()
        }
    }
    
    func handleTimer() {
        print(#function)
    }

}

然后像下面这样使用它。

let task = Task{
    do{
        let c = await MyClass()
        try await c.startTimer(withTimeInterval: 1, upperLimit: 10)
    }catch{
        print(error)
    }
}

使用此设置，您可以取消计时器/任务

task.cancel()

Answer 3

我认为理解这种情况的方法是分阶段进行。 让我们从没有任何类型的async/await标记开始：

class MyClass {
    func startTimer() {
        _ = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { timer in
            self.handleTimer()
        }
    }
    func handleTimer() {}
}

好吧，我们都知道我们可以这样说话； 我们多年来一直这样做。 现在让我们将 MyClass 标记为@MainActor ：

@MainActor
class MyClass {
    func startTimer() {
        _ = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { timer in
            self.handleTimer() // warning -> error
        }
    }
    func handleTimer() {}
}

现在self.handleTimer()引发了一个警告，我们被告知，当 Swift 并发在 Swift 6 中完全实现时，它将演变成一个错误：“在同步非隔离上下文中调用主参与者隔离实例方法‘handleTimer()’ ”

显然，编译器怀疑这一行中的某些内容。 但是什么？ 正如您自己所说， handleTimer似乎无伤大雅。 但是，让我们退后一步。 这些年来，我们已经习惯了这样一种观念，即一般情况下事情往往会发生在“主线程”上。 只要这是普遍正确的，就不存在任何线程问题。 如果我们从视图控制器调用handleTimer ，一切都很好：

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        MyClass().handleTimer()
    }
}

没问题。 但没那么快。 没有问题，只是因为 ViewController 作为 UIViewController也被标记为@MainActor （隐式）。 一旦我们引入一个没有这种标记的类，事情就会迅速崩溃：

class OtherClass {
    func test() {
        MyClass().handleTimer() // BLAAAAAAAAAAP!
    }
}

哇。 关于那条线的一切都被证明是非法的。 我们不仅不能调用handleTimer ，我们甚至不能调用 MyClass 初始化器！！！

为什么这里有问题？ 让我们从历史的角度来看这个问题。 在你睡觉的时候，Apple 悄悄地为所有你最喜欢的 UIKit 类附加了一个@MainActor名称，并开启了 Swift 并发的开端。 但是因为 Apple 将这个名称附加到所有你最喜欢的 UIKit 类上，你甚至没有注意到； 它只是一堆在同一个演员（即主要演员）上互相调用的方法，所以编译器非常高兴。

然而，在这样的世界中，我们的 OtherClass 是一个陌生人。 它没有声明为@MainActor 。 因此，当它与 MyClass 对话时，它会跨越 actor 上下文——编译器会向我们倾诉它的全部愤怒。

显然，我们可以通过将 OtherClass 带入我们快乐的@MainActor世界来解决问题：

@MainActor
class OtherClass {
    func test() {
        MyClass().handleTimer() // no problem :)
    }
}

我们也可以通过引入完整的async/await来解决它，这就是当你想跨 actor 上下文交谈时所做的事情：

class OtherClass {
    func test() {
        Task {
            await MyClass().handleTimer()
        }
    }
}

在该代码中，我们不保证 OtherClass 绑定到哪个 actor（如果有），或者 Task 绑定到哪个 actor（如果有）。 但是我们可以通过正确地跨越 actor 上下文来表现一致，即通过在async上下文世界中说await ，即任务。

好的。 所以现在我们准备好解决您原来的问题，一切都很好，正如我们所展示的，直到您在 MyClass 上说@MainActor 。 那时，出现了一个问题： self.handleTimer()行的参与者状态是什么？

@MainActor
class MyClass {
    func startTimer() {
        _ = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { timer in
            self.handleTimer() // warning -> error
        }
    }
    func handleTimer() {}
}

编译器说：“这一行属于定时器（和运行时），而不属于你。这个self.handleTimer()调用来自 MyClass外部。但是 MyClass 绑定到主要参与者，所以你不能这样做那，我（编译器）现在会原谅你，因为如果我不这样做。你所有现有项目中每个 UIKit 类中的所有计时器代码都会中断，但我警告你，我不会去以后要这么随和！”

要解决这个问题，一种方法是保证self.handleTimer()将在主要参与者上。 一种方法是将调用包装在 MainActor 块中。 但是我们不能在非异步上下文中这样做； 例如，这根本无法编译：

@MainActor
class MyClass {
    func startTimer() {
        _ = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { timer in
            MainActor.run { // No way!!!!
                self.handleTimer()
            }
        }
    }
    func handleTimer() {}
}

相反，我们必须利用刚刚学到的教训。 我们需要进入异步上下文——因为 Timer 块甚至不属于我们，我们只能通过引入任务来实现。 然后我们可以将该任务的内部标记为与主要参与者相关联，整个问题就消失了：

@MainActor
class MyClass {
    func startTimer() {
        _ = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { timer in
            Task { @MainActor in
                self.handleTimer()
            }
        }
    }
    func handleTimer() {}
}

显然，另一种方法是，不在任务中使用@MainActor ，而是使用完整的async/await对话，这样我们就可以跨越 actor 上下文：

@MainActor
class MyClass {
    func startTimer() {
        _ = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { timer in
            Task {
                await self.handleTimer()
            }
        }
    }
    func handleTimer() {}
}

最后但同样重要的是，我们可以按照 jrturton 所说的去做：将handleTimer本身标记为无害的。 这很棘手，因为您是在告诉编译器您知道的比它知道的多，这总是有风险的（就像您使用as!时一样）。 但是由于handleTimer目前是空的，我们当然可以摆脱它：

@MainActor
class MyClass {
    func startTimer() {
        _ = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { timer in
                self.handleTimer()
            }
    }
    nonisolated func handleTimer() {}
}