Qt MDI应用中QUndoCommand耗时操作的多线程实现问题咨询

我之前在做Qt MDI应用时也碰到过几乎一模一样的问题，结合undo/redo框架和异步耗时操作确实得绕几个弯，给你分享几个经过实践验证的解决方案：

把原来的单个耗时命令拆成两个独立的QUndoCommand，核心是让redo()只负责触发异步操作，后续的状态确认和栈恢复交给操作完成后的回调：

• 第一步：创建StartLongOpCommand，它的redo()只做三件事：启动耗时操作的线程、禁用QUndoStack（调用stack->setEnabled(false)）、保存操作所需的上下文数据。执行完立刻返回，主线程不会冻结。
• 第二步：当子线程完成耗时操作后，通过信号槽通知主线程，主线程再将FinishLongOpCommand压入undo栈，同时重新启用QUndoStack。这个完成命令负责确认操作结果、更新UI（比如刷新MDI窗口内容）。
• 反向undo时逻辑反过来：先执行FinishLongOpCommand的undo()（清理操作结果），再启动反向耗时操作的线程，完成后压入StartLongOpCommand的undo逻辑，最后恢复栈的可用状态。

关键细节：一定要处理线程异常（比如操作失败、中途被中断），此时要及时恢复栈的可用状态，并给用户明确的错误提示，避免应用陷入不可操作的状态。

如果不想拆分命令，可以给自定义QUndoCommand添加运行状态标记，配合重写QUndoStack的方法来阻止用户在操作完成前触发其他命令：

1. 在你的耗时命令类里添加m_isRunning布尔标记，以及一个finished信号。
2. redo()方法里启动线程后，立刻设置m_isRunning = true并返回，同时通过QFutureWatcher或者自定义线程的finished信号监听操作完成。
3. 重写QUndoStack的canUndo()和canRedo()方法：当检测到当前/下一个命令是耗时命令且处于运行状态时，返回false，阻止用户触发新的undo/redo操作。
4. 线程完成后，更新m_isRunning = false，触发finished信号，栈自动恢复正常操作逻辑。

这种方式能保持命令的整体性，但需要你对QUndoStack做少量定制。

如果你的耗时操作适合用QtConcurrent执行，可以用QFutureWatcher来简化线程生命周期管理，下面是一个简化的实现示例：

class LongOperationCommand : public QUndoCommand
{
public:
    LongOperationCommand(QUndoStack* stack, QObject* parent = nullptr)
        : QUndoCommand(parent), m_stack(stack), m_watcher(new QFutureWatcher<void>(this))
    {
        // 监听操作完成信号
        connect(m_watcher, &QFutureWatcher<void>::finished, this, [this]() {
            m_isRunning = false;
            m_stack->setEnabled(true);
            // 这里可以添加UI更新逻辑，比如刷新MDI窗口内容
        });
    }

    void redo() override {
        m_stack->setEnabled(false);
        m_isRunning = true;
        // 启动异步耗时操作
        m_future = QtConcurrent::run([this]() {
            // 替换成你的实际耗时逻辑
            executeLongRunningTask();
        });
        m_watcher->setFuture(m_future);
    }

    void undo() override {
        m_stack->setEnabled(false);
        m_isRunning = true;
        // 启动反向耗时操作
        m_future = QtConcurrent::run([this]() {
            // 替换成你的反向操作逻辑
            undoLongRunningTask();
        });
        m_watcher->setFuture(m_future);
    }

    bool isRunning() const { return m_isRunning; }

private:
    QUndoStack* m_stack;
    QFutureWatcher<void>* m_watcher;
    QFuture<void> m_future;
    bool m_isRunning = false;

    void executeLongRunningTask() { /* 你的耗时操作 */ }
    void undoLongRunningTask() { /* 反向操作 */ }
};

然后自定义QUndoStack来限制操作时机：

class CustomUndoStack : public QUndoStack
{
public:
    using QUndoStack::QUndoStack;

    bool canUndo() const override {
        if (const auto cmd = currentCommand()) {
            if (const auto longCmd = qobject_cast<LongOperationCommand*>(cmd)) {
                return !longCmd->isRunning() && QUndoStack::canUndo();
            }
        }
        return QUndoStack::canUndo();
    }

    bool canRedo() const override {
        if (const auto cmd = nextCommand()) {
            if (const auto longCmd = qobject_cast<LongOperationCommand*>(cmd)) {
                return !longCmd->isRunning() && QUndoStack::canRedo();
            }
        }
        return QUndoStack::canRedo();
    }
};

• 线程安全第一：绝对不能在子线程里直接操作UI对象或者共享的业务数据，要用信号槽或者QMetaObject::invokeMethod在主线程处理UI更新和数据同步。
• 状态一致性：无论操作成功还是失败，都要确保undo/redo栈回到可操作状态，比如操作失败时要弹出未完成的命令，或者标记为失败状态，避免栈逻辑混乱。
• 用户反馈：异步操作期间，给用户一个清晰的加载提示（比如鼠标变成忙碌状态、显示进度条），让用户知道程序在后台运行，而不是卡顿崩溃。

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