如何让Swift并发的两个Actor共享同一线程以避免线程切换？

问题场景 #

在两个类之间处理约10000个事件，一个类负责获取事件，另一个类将事件存储到字典中。由于获取类除了传递数据还需对数据执行其他处理，因此不适合批量传递数据，当前代码实现如下：

actor Fetcher {
  let someProcessor = Processor()

  func getData() async {
    let results = await Rest.getData()
    for result in results {
      await someProcessor.doStuff(with: result)
      await someOtherObject.handle(result)
    }
  }
}

actor Processor {
  func doStuff(with result: Result) async {
    // ...
  }
}

当前遇到的问题：两个类均为Actor时，频繁的线程切换导致处理10000条结果耗时8秒；若移除actor关键字改为非线程安全实现，耗时可降至1秒，但会丢失线程安全相关功能。请问是否可以让Swift指定这两个Actor始终运行在同一线程以避免切换？

解决方案 #

Swift本身并不支持直接指定Actor运行在某个特定线程，Actor的调度由Swift并发运行时自动管理，无法手动绑定固定线程。但可以通过以下几种方式优化性能：

1. 合并Actor职责 #

如果Fetcher和Processor的职责高度耦合，且不需要独立的线程安全边界，直接将两者逻辑合并到同一个Actor中。这样所有操作都在同一个Actor执行上下文完成，彻底消除线程切换开销，同时保留线程安全：

actor CombinedFetcherProcessor {
    func getData() async {
        let results = await Rest.getData()
        for result in results {
            self.doStuff(with: result)
            await someOtherObject.handle(result)
        }
    }

    func doStuff(with result: Result) {
        // 原Processor的处理逻辑
    }
}

2. 批量处理减少跨Actor调用次数 #

虽然无法完全批量传递数据，但可以将结果打包成批次提交给Processor，大幅降低跨Actor调用的频率（从10000次降到几十次），从而减少线程切换的开销：

actor Fetcher {
    let someProcessor = Processor()

    func getData() async {
        let results = await Rest.getData()
        let batchSize = 100
        // 将结果分批处理
        for batch in results.chunked(into: batchSize) {
            await someProcessor.doStuff(withBatch: batch)
            for result in batch {
                await someOtherObject.handle(result)
            }
        }
    }
}

actor Processor {
    func doStuff(withBatch batch: [Result]) async {
        for result in batch {
            // 原单条结果的处理逻辑
        }
    }
}

// 给数组添加分批扩展
extension Array {
    func chunked(into size: Int) -> [[Element]] {
        stride(from: 0, to: count, by: size).map {
            Array(self[$0..<Swift.min($0 + size, count)])
        }
    }
}

3. 用GCD串行队列替代Actor控制执行上下文 #

如果必须拆分两个类，可以使用GCD的串行队列来手动统一执行上下文，确保两个类的操作都在同一个串行队列上执行（串行队列的任务默认会在同一线程执行，除非队列被阻塞），以此模拟“同一线程”的效果：

class Fetcher {
    private let sharedQueue: DispatchQueue
    private let someProcessor: Processor

    init(sharedQueue: DispatchQueue, processor: Processor) {
        self.sharedQueue = sharedQueue
        self.someProcessor = processor
    }

    func getData() async {
        let results = await Rest.getData()
        for result in results {
            // 在共享串行队列执行Processor的处理逻辑
            await sharedQueue.async {
                self.someProcessor.doStuff(with: result)
            }
            await someOtherObject.handle(result)
        }
    }
}

class Processor {
    private let sharedQueue: DispatchQueue

    init(sharedQueue: DispatchQueue) {
        self.sharedQueue = sharedQueue
    }

    func doStuff(with result: Result) {
        // 确保处理逻辑在共享队列执行
        sharedQueue.sync {
            // 原处理逻辑
        }
    }
}

// 初始化时传入同一个串行队列
let sharedQueue = DispatchQueue(label: "com.yourdomain.fetcher-processor")
let processor = Processor(sharedQueue: sharedQueue)
let fetcher = Fetcher(sharedQueue: sharedQueue, processor: processor)

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