GlobalActor指令不能保证该演员会调用功能

Question

假设我已经定义了一个全球演员：

@globalActor actor MyActor {
    static let shared = MyActor()
}

并且我有一个类，其中几种方法需要采取以下操作：

class MyClass {

    @MyActor func doSomething(undoManager: UndoManager) {

        // Do something here
   
        undoManager?.registerUndo(withTarget: self) { 
            $0.reverseSomething(undoManager: UndoManager)
        }
    }

    @MyActor func reverseSomething(undoManager: UndoManager) {

        // Do the reverse of something here

        print(\(Thread.isMainThread) /// Prints true when called from undo stack
   
        undoManager?.registerUndo(withTarget: self) { 
            $0.doSomething(undoManager: UndoManager)
        }
    }
}

假设代码从swiftui视图中调用：

struct MyView: View {
   @Environment(\.undoManager) private var undoManager: UndoManager?
   let myObject: MyClass

   var body: some View {
        Button("Do something") { myObject.doSomething(undoManager: undoManager) }
   }
}

请注意，当操作被撤销时，“反向反向” func是打电话给主要线程。防止这种情况包裹在任务中的正确方法是正确的吗？如：

    @MyActor func reverseSomething(undoManager: UndoManager) {

        // Do the reverse of something here

        print(\(Thread.isMainThread) /// Prints true
   
        undoManager?.registerUndo(withTarget: self) { 
            Task { $0.doSomething(undoManager: UndoManager) }
        }
    }

Answer 1

令我惊讶的是，编译器不会在同步的非分离上下文（即关闭）中引起全局演员为“ myActor”的实例方法的警告。看来，编译器被隔离方法中的闭合语法混淆了。

无论如何，您可以将其包裹在任务中，并且应该在适当的演员上运行：

@MyActor func doSomething(undoManager: UndoManager) {
    // Do something here

    undoManager.registerUndo(withTarget: self) { target in
        Task { @MyActor in
            target.reverseSomething(undoManager: undoManager)
        }
    }
}

---

就说是说，我发现了从背景中使用它时不稳定的undomanager行为线程（即，不在主要演员上）。

因此，尤其是因为撤消/重做是通常是从UI（在主线程上）启动的行为，所以我将其保留在主线程上，并且仅在另一个演员上运行所需的工作。例如：

struct ContentView: View {
    @StateObject var viewModel = ViewModel()
    @State var input: String = ""

    var body: some View {
        VStack {
            TextField(text: $input) {
                Text("enter value")
            }

            Button("Add record") {
                viewModel.addAndPrepareUndo(for: input)
                input = ""
            }.disabled(input.isEmpty)

            Button("Undo") {
                viewModel.undo()
            }.disabled(!viewModel.canUndo)

            Button("Redo") {
                viewModel.redo()
            }.disabled(!viewModel.canRedo)
        }
        .padding()
    }
}

@globalActor actor MyGlobalActor {
    static let shared = MyGlobalActor()
}

@MainActor
class ViewModel: ObservableObject {
    @MyGlobalActor
    var values: [String] = []

    @Published var canUndo = false
    @Published var canRedo = false

    private var undoManager = UndoManager()

    func undo() {
        undoManager.undo()
        updateUndoStatus()
    }

    func redo() {
        undoManager.redo()
        updateUndoStatus()
    }

    func updateUndoStatus() {
        canUndo = undoManager.canUndo
        canRedo = undoManager.canRedo
    }

    func addAndPrepareUndo(for newValue: String) {
        undoManager.registerUndo(withTarget: self) { [weak self] target in
            guard let self else { return }
            self.removeAndPrepareRedo(for: newValue)
        }
        updateUndoStatus()

        Task { @MyGlobalActor in
            values.append(newValue)
            print(#function, values)
        }
    }

    func removeAndPrepareRedo(for revertValue: String) {
        undoManager.registerUndo(withTarget: self) { [weak self] target in
            guard let self else { return }
            self.addAndPrepareUndo(for: revertValue)
        }
        updateUndoStatus()

        Task { @MyGlobalActor in
            values.removeLast()
            print(#function, values)
        }
    }
}

现在，这是一个人为的例子（对于这个简单的事情，我们不会在全球演员上只有一个数组），但希望它说明了这个想法。

或者，您可以使用非全球演员：

struct ContentView: View {
    @StateObject var viewModel = ViewModel()
    @State var input: String = ""

    var body: some View {
        VStack {
            TextField(text: $input) {
                Text("enter value")
            }

            Button("Add record") {
                viewModel.addAndPrepareUndo(for: input)
                input = ""
            }.disabled(input.isEmpty)

            Button("Undo") {
                viewModel.undo()
            }.disabled(!viewModel.canUndo)

            Button("Redo") {
                viewModel.redo()
            }.disabled(!viewModel.canRedo)
        }
        .padding()
    }
}

@MainActor
class ViewModel: ObservableObject {
    var model = Model()

    @Published var canUndo = false
    @Published var canRedo = false

    private var undoManager = UndoManager()

    func undo() {
        undoManager.undo()
        updateUndoStatus()
    }

    func redo() {
        undoManager.redo()
        updateUndoStatus()
    }

    func updateUndoStatus() {
        canUndo = undoManager.canUndo
        canRedo = undoManager.canRedo
    }

    func addAndPrepareUndo(for newValue: String) {
        undoManager.registerUndo(withTarget: self) { [weak self] target in
            guard let self else { return }
            self.removeAndPrepareRedo(for: newValue)
        }
        updateUndoStatus()

        Task {
            await model.append(newValue)
            await print(#function, model.values())
        }
    }

    func removeAndPrepareRedo(for revertValue: String) {
        undoManager.registerUndo(withTarget: self) { [weak self] target in
            guard let self else { return }
            self.addAndPrepareUndo(for: revertValue)
        }
        updateUndoStatus()

        Task {
            await model.removeLast()
            await print(#function, model.values())
        }
    }
}

actor Model {
    private var strings: [String] = []

    func append(_ string: String) {
        strings.append(string)
    }

    func removeLast() {
        strings.removeLast()
    }

    func values() -> [String] {
        strings
    }
}