Swift 6中如何为进程管道实现所有权转移以解决数据竞争报错

问题背景 #

我有一个在Swift 5中运行完全正常的重度多线程应用，切换到Swift 6后仅遇到少量错误，但仍有一个问题无法解决。

代码通过进程管道传递一个非常复杂的数据结构，如下：

//  Can't be Sendable because of the need for mutable properties that will be modified
//  by Process1, Process2 etc...
final class ComplexData  {
    var name: String
    init(name: String) {
        self.name = name
    }
}

func Process1(lotsOfData: [ComplexData]) {
    for data in lotsOfData {
        //  Do complex things with complex data, and then give data to another process
        Task.detached {
            Process2(data: data)
        }
        //  I will never ever do anything more with data
    }
}

func Process2(data: ComplexData) {
    //  Do complex things with complex data, and then give data to another process
    Task.detached {
        Process3(data: data)
    }
    //  I will never ever do anything more with data
}

func Process3(data: ComplexData) {
    //  Do complex things with complex data, and I am done
}

在每个Task.detached行都遇到错误：Task-isolated value of type '() async -> ()' passed as a strongly transferred parameter; later accesses could race。

实际上不存在数据竞争，因为每个ComplexData同一时间仅被一个Process访问。在Rust中，这种“访问时间互斥”可以通过“所有权转移”解决。在Swift 6中该如何正确解决这个问题？

解决方案 #

1. 用consuming关键字实现所有权转移 #

Swift 6新增的consuming关键字可以明确转移值的所有权，确保原作用域在转移后无法再访问对象，从根源避免竞争风险：

final class ComplexData {
    var name: String
    init(name: String) {
        self.name = name
    }
}

func Process1(lotsOfData: [ComplexData]) {
    for var data in lotsOfData {
        // 执行复杂处理逻辑
        Task.detached { [data] in
            await Process2(data: &data)
        }
        // 此处data已被转移，编译器会禁止后续访问
    }
}

func Process2(consuming data: inout ComplexData) async {
    // 执行复杂处理逻辑
    Task.detached { [data] in
        await Process3(data: &data)
    }
    // 此处data已被转移，编译器会禁止后续访问
}

func Process3(consuming data: inout ComplexData) async {
    // 执行最终处理逻辑，完成后data生命周期结束
}

2. 转为值类型（结构体） #

如果业务场景允许，将ComplexData从类改为结构体。值类型天然支持所有权转移，且只要内部属性符合Sendable要求，就能自动满足Swift 6的并发安全检查：

struct ComplexData: Sendable {
    var name: String
    init(name: String) {
        self.name = name
    }
}

func Process1(lotsOfData: [ComplexData]) {
    for data in lotsOfData {
        Task.detached {
            await Process2(data: data)
        }
    }
}

func Process2(data: ComplexData) async {
    Task.detached {
        await Process3(data: data)
    }
}

func Process3(data: ComplexData) async {
    // 执行最终处理逻辑
}

3. 临时兼容：使用unowned（不推荐） #

如果暂时无法修改类结构或使用所有权转移，可以用unowned明确对象的生命周期依赖，但这种方式风险较高，必须确保Task执行期间对象始终存在：

func Process1(lotsOfData: [ComplexData]) {
    for data in lotsOfData {
        Task.detached { [unowned data] in
            Process2(data: data)
        }
    }
}

func Process2(data: ComplexData) {
    Task.detached { [unowned data] in
        Process3(data: data)
    }
}

内容的提问来源于stack exchange，提问作者AirXygène