Qt/C++模块化插件架构中如何优化EventManager以提升性能？

优化方案 #

1. 高频事件节流（Throttling） #

控制单位时间内事件触发的最大次数，比如鼠标移动事件每16ms（约60帧）触发一次，避免短时间内大量事件堆积。

修改Private结构体：

struct EventManager::Private {
    struct EventSlot {
        QPointer<QObject> receiver;
        EventCallback     callback;
    };

    QMutex                          mutex;
    QMap<QString, QList<EventSlot>> events;
    QHash<QString, qint64>          lastTriggerTime; // 记录事件上次触发时间
    const qint64                    throttleInterval = 16; // 节流间隔（ms）
};

修改triggerEvent方法：

void EventManager::triggerEvent(const QString&  aEventName, const QVariant& aValue) noexcept
{
    if (aEventName.isEmpty()) return;

    QMutexLocker locker(&d_ptr->mutex);
    auto now = QDateTime::currentMSecsSinceEpoch();
    // 检查是否需要节流
    if (d_ptr->lastTriggerTime.contains(aEventName)) {
        qint64 elapsed = now - d_ptr->lastTriggerTime[aEventName];
        if (elapsed < d_ptr->throttleInterval) {
            return;
        }
    }
    d_ptr->lastTriggerTime[aEventName] = now;

    // 一次性拷贝事件列表，减少锁持有时间
    auto eventSlots = d_ptr->events.value(aEventName);
    locker.unlock();

    for (const auto& eventSlot : std::as_const(eventSlots)) {
        if (!eventSlot.receiver.isNull()) {
            QMetaObject::invokeMethod(eventSlot.receiver,
                [callback = eventSlot.callback, aEventName, aValue]() {
                callback(aEventName, aValue);
            }, Qt::QueuedConnection);
        }
    }
    emit eventTriggered(aEventName, aValue);
}

2. 事件合并（Debouncing） #

针对连续触发的高频事件（如鼠标移动、窗口 resize），仅处理最后一次事件，避免中间无效触发。通过QTimer延迟执行，若期间有新事件则重置定时器。

修改Private结构体：

struct EventManager::Private {
    struct EventSlot {
        QPointer<QObject> receiver;
        EventCallback     callback;
    };

    struct DebounceData {
        QTimer* timer;
        QVariant latestValue;
    };

    QMutex                          mutex;
    QMap<QString, QList<EventSlot>> events;
    QHash<QString, DebounceData>    debounceMap;
    const int                       debounceDelay = 20; // 延迟时间（ms）
};

修改EventManager构造/析构及triggerEvent：

EventManager::EventManager(QObject *aParent) :
    QObject(aParent),
    d_ptr(new EventManager::Private)
{}

EventManager::~EventManager()
{
    QMutexLocker locker(&d_ptr->mutex);
    for (auto& data : d_ptr->debounceMap) {
        delete data.timer;
    }
    delete d_ptr; 
}

void EventManager::triggerEvent(const QString&  aEventName, const QVariant& aValue) noexcept
{
    if (aEventName.isEmpty()) return;

    // 假设需要防抖的事件前缀为"highFreq_"，可根据实际规则判断
    if (aEventName.startsWith("highFreq_")) {
        QMutexLocker locker(&d_ptr->mutex);
        if (!d_ptr->debounceMap.contains(aEventName)) {
            DebounceData data;
            data.timer = new QTimer(this);
            data.timer->setSingleShot(true);
            connect(data.timer, &QTimer::timeout, this, [this, aEventName]() {
                QMutexLocker locker(&d_ptr->mutex);
                auto value = d_ptr->debounceMap[aEventName].latestValue;
                auto eventSlots = d_ptr->events.value(aEventName);
                locker.unlock();

                for (const auto& eventSlot : std::as_const(eventSlots)) {
                    if (!eventSlot.receiver.isNull()) {
                        QMetaObject::invokeMethod(eventSlot.receiver,
                            [callback = eventSlot.callback, aEventName, value]() {
                            callback(aEventName, value);
                        }, Qt::QueuedConnection);
                    }
                }
                emit eventTriggered(aEventName, value);

                // 清理防抖数据
                locker.relock();
                delete d_ptr->debounceMap[aEventName].timer;
                d_ptr->debounceMap.remove(aEventName);
            });
            d_ptr->debounceMap[aEventName] = data;
        }
        // 更新最新值并重置定时器
        auto& data = d_ptr->debounceMap[aEventName];
        data.latestValue = aValue;
        data.timer->start(d_ptr->debounceDelay);
        return;
    }

    // 普通事件处理逻辑（复用节流优化后的代码）
    QMutexLocker locker(&d_ptr->mutex);
    auto eventSlots = d_ptr->events.value(aEventName);
    locker.unlock();

    for (const auto& eventSlot : std::as_const(eventSlots)) {
        if (!eventSlot.receiver.isNull()) {
            QMetaObject::invokeMethod(eventSlot.receiver,
                [callback = eventSlot.callback, aEventName, aValue]() {
                callback(aEventName, aValue);
            }, Qt::QueuedConnection);
        }
    }
    emit eventTriggered(aEventName, aValue);
}

3. 优化锁机制与事件分发 #

• 减少锁的持有时间：一次性拷贝事件列表，避免在遍历回调时持有锁
• 移除不必要的加解锁操作：原代码中多次lock/unlock可合并为一次
• 对于不需要跨线程的回调，直接调用而非使用QMetaObject::invokeMethod，减少Qt事件队列开销

修改triggerEvent中的回调调用逻辑：

// 在遍历回调时，判断接收者是否与当前线程同属一个线程
for (const auto& eventSlot : std::as_const(eventSlots)) {
    if (eventSlot.receiver.isNull()) continue;

    if (eventSlot.receiver->thread() == QThread::currentThread()) {
        // 同线程直接调用，避免队列开销
        eventSlot.callback(aEventName, aValue);
    } else {
        QMetaObject::invokeMethod(eventSlot.receiver,
            [callback = eventSlot.callback, aEventName, aValue]() {
            callback(aEventName, aValue);
        }, Qt::QueuedConnection);
    }
}

4. 事件分类管理 #

在注册事件时允许标记事件类型（高频/普通），针对性应用节流或防抖策略，避免对所有事件统一处理。

修改registerEvent方法，增加事件类型参数：

enum class EventType {
    Normal,
    Throttled,
    Debounced
};

void registerEvent(const QString &eventName, QObject *receiver, EventCallback callback, EventType type = EventType::Normal) noexcept;

在Private结构体中增加事件类型映射：QHash<QString, EventType> eventTypes;，后续在triggerEvent中根据类型选择处理逻辑。

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