如果您想通过1的maxConcurrentOperationCount（“串行”操作队列）获得OperationQueue的行为，可以通过actor实现。
串行OperationQueue有两种模式：
1.队列中的操作本身是同步的。
如果你使用标准的OperationQueue（也就是说，你还没有子类化Operation，Operation为isFinished做手动KVO，等等），一个简单的actor就可以达到我们想要的效果。
这里的关键是，这只适用于同步方法（即那些没有await挂起点的方法）。
1.队列中的操作是异步的。
操作队列的一个更高级的用例是处理异步任务之间的依赖关系。这在操作队列中是一个更复杂的场景，需要一个自定义的Operation子类，在其中手动处理isFinished的KVO，等等。（参见该模式的示例的答案）
使用Swift并发执行此操作的挑战在于参与者是可重入的（参见SE-0306中的可重入性讨论）。如果参与者的方法是异步的（即，具有async-await），则会引入挂起点，即，一个调用中的await将允许另一个async方法在该参与者上运行。
要实现不同async方法之间的串行执行，必须保留对前面的Task的引用并等待它。但是必须小心，其中调度方法（下面示例中的add）是同步的。
请考虑以下示例（它使用操作系统路标，以便我能够以图形方式说明Instruments中的行为）：

import os.signpost

private let pointsOfInterest = OSLog(subsystem: "log", category: .pointsOfInterest)

class ViewController: UIViewController {

    let example = Example()
    let taskSerializer = SerialTasks<Void>()

    @IBAction func didTapSync(_ sender: Any) {
        os_signpost(.event, log: pointsOfInterest, name: #function)
        startSynchronous()
    }

    @IBAction func didTapAsync(_ sender: Any) {
        os_signpost(.event, log: pointsOfInterest, name: #function)
        Task { try await startAsynchronous() }
    }

    @IBAction func didTapSerializedAsync(_ sender: Any) {
        os_signpost(.event, log: pointsOfInterest, name: #function)
        Task { try await startSerializedAsynchronous() }
    }

    func startSynchronous() {
        Task {
            await example.synchronousExample("1. synchronous")
        }
    }

    func startAsynchronous() async throws {
        try await example.asynchronousExample("2. asynchronous")
    }

    func startSerializedAsynchronous() async throws {
        try await taskSerializer.add {
            try await self.example.asynchronousExample("3. serial async")
        }
    }
}

actor Example {
    func asynchronousExample(_ name: StaticString) async throws {
        let id = OSSignpostID(log: pointsOfInterest)
        os_signpost(.begin, log: pointsOfInterest, name: name, signpostID: id)
        defer { os_signpost(.end, log: pointsOfInterest, name: name, signpostID: id) }

        try await Task.sleep(for: .seconds(2))
    }

    func synchronousExample(_ name: StaticString) {
        let id = OSSignpostID(log: pointsOfInterest)
        os_signpost(.begin, log: pointsOfInterest, name: name, signpostID: id)
        defer { os_signpost(.end, log: pointsOfInterest, name: name, signpostID: id) }

        Thread.sleep(forTimeInterval: 2)
    }
}

actor SerialTasks<Success> {
    private var previousTask: Task<Success, Error>?

    func add(block: @Sendable @escaping () async throws -> Success) async throws -> Success {
        let task = Task { [previousTask] in
            let _ = await previousTask?.result
            return try await block()
        }
        previousTask = task
        return try await task.value
    }
}

对于同步任务（场景1），startSynchronous是最简单的，只需调用actor的synchronous方法，就可以串行执行。
对于异步任务（场景2）startAsynchronous，如果有await挂起点，则会由于执行元可重入而丢失顺序行为。
但是，您可以细化异步任务模式（场景3），方法是在上面的代码中使用一个actor SerialTasks，它跟踪前一个任务，在开始下一个任务之前等待它。一个微妙的点是add方法本身是同步的（尽管它所采用的闭包是异步的）。这避免了添加多个任务时的微妙竞争。
在Instruments中运行上述命令，我们可以图形化地看到执行情况，其中ⓢ路标显示任务启动的位置，间隔显示任务执行的时间：

简而言之，如果您的actor只执行同步任务（这是您的情况），那么actor会自动产生maxConcurrentOperationCount = 1类型的行为;如果任务是异步的，您只需在开始下一个任务之前执行await之前的任务。