MainActor 隔离可变存储属性为何会出现可发送错误？

Question

我正在尝试使 class 符合Sendable 。 我有一些导致问题的可变存储属性。 但是，我无法理解的是 MainActor 隔离属性不允许我的 class 符合 Sendable。 但是，如果我将整个 class 标记为@MainActor ，那就没问题了。 但是，我实际上并不想让整个 class 符合@MainActor 。

举个例子，拿这段代码：

final class Article: Sendable {
  @MainActor var text: String = "test"
}

它给出了这个警告： Stored property 'text' of 'Sendable'-conforming class 'Article' is mutable 。

有人可以解释为什么吗？ 我认为与演员隔离会很好。

Answer 1

该错误警告您 class 具有可变属性。 该可变属性可以从 Swift 并发之外访问，因此不安全。

考虑以下：

final class Foo: Sendable {
    @MainActor var counter = 0   // Stored property 'counter' of 'Sendable'-conforming class 'Foo' is mutable
}

我们现在可以考虑视图 controller 的以下属性和方法，它直接与counter交互：

let foo = Foo()

func incrementFooManyTimes() {
    DispatchQueue.global().async { [self] in
        DispatchQueue.concurrentPerform(iterations: 10_000_000) { _ in
            foo.counter += 1
        }
        print(foo.counter)   // 6146264 !!!
    }
}

注意：如果您确实将“Swift Concurrency Checking”构建设置设置为“Minimal”或“Targeted”，则以上内容将仅在上述警告的情况下进行编译。 （如果你把它改成“Complete”，它就变成了一个硬错误。）

简而言之，您已将 标记为@MainActor ，但没有什么可以阻止其他线程直接与 class 的此属性进行交互。 要使类型成为Sendable ，它必须：

• 是不可变的；
• 手动同步其属性； 或者
• 做actor

---

如果您要让非参与者成为具有可变属性的Sendable ，您必须自己实现线程安全。 例如：

final class Foo: @unchecked Sendable {
    private var _counter = 0
    private let queue: DispatchQueue = .main    // I would use `DispatchQueue(label: "Foo.sync")`, but just illustrating the idea

    var counter: Int { queue.sync { _counter } }

    func increment() {
        queue.sync { _counter += 1 }
    }
}

和

func incrementFooManyTimes() {
    DispatchQueue.global().async { [self] in
        DispatchQueue.concurrentPerform(iterations: 10_000_000) { _ in
            foo.increment()
        }
        print(foo.counter)   // 10000000
    }
}

显然，您也可以限制自己使用不可变属性，并且不需要同步。 但我假设你需要可变性。

现在，在这个可变场景中，您可以使用任何您想要的同步机制，但希望这能说明这个想法。 简而言之，如果你打算让它在 Swift 并发之外发生变异，你必须自己实现同步。 因为我们正在实现我们自己的同步，我们告诉编译器它是@unchecked ，这意味着您不会让编译器检查它的正确性，而是这个负担落在您的肩上。

---

显然，如果您使用 actor 并留在 Swift 并发的世界中，生活会容易得多。 例如：

actor Bar {
    var counter = 0

    func increment() {
        counter += 1
    }
}

和：

let bar = Bar()

func incrementBarManyTimes() {
    Task.detached {
        await withTaskGroup(of: Void.self) { group in
            for _ in 0 ..< 10_000_000 {
                group.addTask { await self.bar.increment() }
            }
            await print(self.bar.counter)
        }
    }
}

Answer 2

阅读 Swift Evolution 提案，似乎尚未设计/实施复杂的Sendable一致性检查。

从global actors 提议中，据说标有 global actor 的类型隐式符合Sendable 。

用全局参与者注释的非协议类型隐式符合Sendable 。 这种类型的实例可以安全地跨并发域共享，因为对其 state 的访问受到全局参与者的保护。

所以你甚至不需要: Sendable如果你用@MainActor标记你的最终 class 就可以发送！

另一方面， Sendable的提案提到：

类的可发送一致性检查

[...] class 可能符合 Sendable 并在特定的有限情况下由编译器检查 memory 安全性：当 class 是最终的 class 时，它仅包含符合 Sendable 的类型的不可变存储属性：

 final class MyClass: Sendable { let state: String }

基本上，如果您不使用全局演员标记您的最终 class，则您的 class 中的每个存储属性都需要是一个let 。

我无法在这两个文档中找到任何其他内容，也无法在 Swift Evolution 上找到其他相关提案。

所以现在的设计根本不关心你有没有给属性加上@MainActor 。 最终 class 符合Sendable的两个充分条件

Sendable提案还提到：

未来有几种方法可以概括这一点，但有一些不明显的案例需要确定。 因此，该提案有意限制类的安全检查，以确保我们在并发设计的其他方面取得进展。