为何被MainActor隔离的可变存储属性会触发Sendable错误？

为什么单个属性标记@MainActor无法让类遵循Sendable？ #

Sendable协议的核心要求是：类型实例可以安全地在不同线程/actor之间传递，这意味着类型的所有状态必须保证线程安全。

对于final类来说，当你声明它遵循Sendable时，编译器会做严格的静态检查：

• 不可变的let属性：只要属性本身是Sendable类型就没问题；
• 可变的var属性：必须满足以下任一条件：
  1. 整个类被actor隔离（比如标记@MainActor），这样所有属性的访问都会被该actor的串行执行逻辑保护；
  2. 属性本身是线程安全的Sendable类型（比如原子操作包装的类型）。

你遇到的问题在于：仅给单个属性标记@MainActor时，类本身并没有被actor隔离——类的实例可以被传递到任意线程。编译器无法静态验证所有对这个可变属性的访问都严格遵循@MainActor的上下文要求（比如有人可能在非主线程直接访问它，虽然会触发编译错误，但Sendable的检查是在类型层面，确保类型本身天生安全，而非依赖使用方式）。因此编译器认为这个可变属性存在线程安全风险，抛出警告。

解决方案（无需标记整个类为@MainActor） #

1. 使用原子类型包装属性（推荐） #

Swift 5.9引入了Atomic类型（需导入_Concurrency），可以安全地处理线程间的可变状态：

import _Concurrency

final class Article: Sendable {
  private let _text = Atomic<String>("test")
  
  @MainActor var text: String {
    get { _text.load(ordering: .relaxed) }
    set { _text.store(newValue, ordering: .relaxed) }
  }
}

底层存储用原子操作保证线程安全，外部访问通过@MainActor限制在主线程，同时类满足Sendable要求。

2. 封装private属性，提供异步访问方法 #

将属性设为私有，通过异步方法确保所有读写操作都在MainActor上下文执行：

final class Article: Sendable {
  private var _text: String = "test"
  
  func getText() async -> String {
    await MainActor.run { _text }
  }
  
  func setText(_ newValue: String) async {
    await MainActor.run { _text = newValue }
  }
}

这种方式需要通过异步方法访问属性，适合对访问方式有明确控制的场景。

3. 自定义线程安全的属性包装器 #

可以封装一个@MainActorWrapped属性包装器，统一处理主线程的读写逻辑：

@propertyWrapper
struct MainActorWrapped<T>: Sendable where T: Sendable {
  @MainActor private var value: T
  
  init(wrappedValue: T) {
    self.value = wrappedValue
  }
  
  // 注意：同步访问可能存在死锁风险，建议用异步get/set（Swift 5.5+支持）
  var wrappedValue: T {
    get async { @MainActor in value }
    set async { @MainActor in value = newValue }
  }
}

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

使用时需要通过await访问属性，避免死锁问题。

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