瑶池酒剑仙头像
C++事件系统与回调队列完全指南:从类型擦除到优先级调度的工程实践(渔舟唱晚)封面图

C++事件系统与回调队列完全指南:从类型擦除到优先级调度的工程实践(渔舟唱晚)

📣📣📣📣📣📣📣📣
✏️作者主页:瑶池酒剑仙
📋 系列专栏:C++基础宝典
🌲上一篇: C++std::function与类型擦除完全指南:从回调到事件系统的深度剖析
🌲下一篇: C++异常处理完全指南:从try/catch/throw到RAII、异常安全与noexcept的工程实践
📣📣📣📣📣📣📣📣

🎍逐梦编程,让中华屹立世界之巅。
🎍简单的事情重复做,重复的事情用心做,用心的事情坚持做;

在这里插入图片描述


引言:从"一个大 vector"到"生产级事件总线"

上一篇讲 std::function 时,最后那个"优先级回调队列"已经能"跑"了。但**“能跑"和"生产可用"是两回事**——我见过太多团队,用 std::vector<std::function> 搭了个"事件系统”,上线后碰到一堆问题:

  • 订阅者"边遍历边取消订阅" → 迭代器失效 → 崩溃
  • 订阅者对象被销毁,但回调还在 → 悬空 → 段错误
  • A 回调里"触发 B 事件",B 回调里"又触发 A 事件" → 无限递归 → 栈溢出
  • 多线程同时触发/订阅 → 数据竞争 → 随机崩溃
  • 某回调"抛异常" → 整个 dispatch 中断 → 后面的回调收不到

这些不是"使用错误",而是"架构缺陷"——一个"生产级事件系统"需要在设计层面就解决这些问题。

我做过几个项目的"事件总线"(从"游戏引擎"到"微服务框架"),总结下来,一个成熟的事件系统需要处理:

  • 类型安全:事件类型、回调签名、编译期检查
  • 生命周期:订阅者销毁时自动取消订阅(weak_ptr)
  • 并发安全:多线程订阅/触发/取消
  • 异常隔离:单个回调抛异常不影响其他回调
  • 递归安全:回调中触发新事件不崩溃
  • 优先级:高优先级回调先执行
  • 性能:避免 std::function 的"每次调用开销"

这一篇,把"事件系统与回调队列"的工程实践讲透:

  • 事件系统架构:EventBus / Publisher / Subscriber 三层设计
  • 类型安全的事件:用"类型标签 + std::variant"定义事件
  • 生命周期管理:weak_ptr + shared_ptr 的订阅者检查
  • 并发安全:shared_mutex + 快照遍历
  • 异常隔离:try/catch 包裹每个回调
  • 递归安全:任务队列 + 延迟执行
  • 优先级调度:priority_queue + 序列号
  • 线程池:thread + 回调队列
  • 性能优化:模板参数 + 类型擦除的"混合策略"
  • 综合实战:一个"完整的事件总线"

代码在 GCC 13 / Clang 17 上验证过。涉及"并发安全"的地方,我用 -fsanitize=thread 验证过"无数据竞争"。


一、事件系统架构

1.1 三种"角色"

事件系统有三层:

角色职责典型 API
事件(Event)描述"发生了什么"struct ClickEvent { int x, y; };
发布者(Publisher)产生事件publish(ClickEvent{...})
订阅者(Subscriber)处理事件subscribe<ClickEvent>([](const ClickEvent& e) { ... })

EventBus 是"中介"——解耦"发布者"和"订阅者":

Publisher A ──publish──> EventBus ──dispatch──> Subscriber X
Publisher B ──publish──>         ──dispatch──> Subscriber Y
Publisher C ──publish──>         ──dispatch──> Subscriber Z

"解耦"的价值:发布者不需要知道"谁订阅"——它只管"发",订阅者"收"。这带来"模块化"和"可测试性"。

代码如下(示例):

/*-----------------------------------【程序说明】----------------------------
*			 项目命题:   C++基础宝典
*			 代码所属:   瑶池酒剑仙(枫之剑客)
*			     作者:   阿甘
*		     开发时间:   2026/11/19
*			IDE 版 本:   Visual Studio 2026
*		     项目版本:   1.0.0.1
*---------------------------------------------------------------------------*/
//原文链接:https://ganzp1688.blog.csdn.net/?type=blog

#include <iostream>
#include <functional>
#include <vector>
#include <string>
using namespace std;

// ========== 最简事件系统("能跑"版) ==========
template<typename Event>
class SimpleEventBus {
private:
    vector<function<void(const Event&)>> subscribers_;

public:
    void subscribe(function<void(const Event&)> cb) {
        subscribers_.push_back(std::move(cb));
    }

    void publish(const Event& event) {
        for (auto& cb : subscribers_) {
            cb(event);
        }
    }
};

// 使用
struct ClickEvent { int x, y; };

void simpleEventBusDemo() {
    cout << "=== 最简事件系统 ===" << endl;

    SimpleEventBus<ClickEvent> bus;

    bus.subscribe([](const ClickEvent& e) {
        cout << "订阅者 A: 点击 (" << e.x << ", " << e.y << ")" << endl;
    });

    bus.subscribe([](const ClickEvent& e) {
        cout << "订阅者 B: 点击 (" << e.x << ", " << e.y << ")" << endl;
    });

    bus.publish({10, 20});

    // 这个版本"能跑"——但有"五大问题":
    // 1. 不能"取消订阅"
    // 2. 订阅者销毁后回调悬空
    // 3. 多线程不安全
    // 4. 回调抛异常会中断
    // 5. 不能"边触发边订阅"(迭代器失效)
    //
    // 后面逐个解决。
}

1.2 "五大问题"的解决方案

问题解决方案
不能"取消订阅"“订阅 ID” + “取消 API”
订阅者销毁后悬空weak_ptr 检查
多线程不安全mutex / shared_mutex
回调抛异常中断每个回调 try/catch
迭代器失效"快照"遍历 / “任务队列”

二、生命周期管理:weak_ptr 的"自动取消订阅"

2.1 "订阅者销毁"的"悬空"问题

问题:订阅者对象销毁了,但 EventBus 里的 lambda 还"活着"——如果 lambda 捕获了"订阅者的 this",调用就是悬空。

class Button {
public:
    void onClick(const ClickEvent& e) {
        cout << "Button 被点击 (" << e.x << ", " << e.y << ")" << endl;
    }
};

void danglingSubscriberDemo() {
    cout << "\n=== 订阅者悬空 ===" << endl;

    SimpleEventBus<ClickEvent> bus;

    // 错误:捕获 this 指针
    {
        Button btn;
        bus.subscribe([&btn](const ClickEvent& e) {
            btn.onClick(e);   // btn 销毁后,this 悬空!
        });
    }
    // btn 销毁

    // bus.publish({10, 20});   // UB!访问悬空的 this

    cout << "(不执行悬空访问,仅演示问题)" << endl;
}

2.2 weak_ptr 的"订阅者检查"

解决方案:订阅者用 shared_ptr 管理,回调捕获 weak_ptr——回调调用前先 lock(),失败就跳过。

#include <memory>

class Button : public std::enable_shared_from_this<Button> {
public:
    void onClick(const ClickEvent& e) {
        cout << "Button 被点击 (" << e.x << ", " << e.y << ")" << endl;
    }
};

template<typename Event>
class SafeEventBus {
private:
    // 订阅者:用 weak_ptr 检查"存活"
    vector<function<void(const Event&)>> subscribers_;

public:
    // 订阅:调用方传"shared_ptr 的 weak 版本"
    template<typename T>
    void subscribeWeak(std::weak_ptr<T> weakSubscriber, 
                       void (T::*method)(const Event&)) {
        subscribers_.push_back([weakSubscriber, method](const Event& e) {
            // 关键:调用前先 lock()
            if (auto shared = weakSubscriber.lock()) {
                (shared.get()->*method)(e);
            }
            // 如果 lock() 失败,说明对象已销毁,跳过
        });
    }

    void publish(const Event& event) {
        for (auto& cb : subscribers_) {
            cb(event);
        }
    }
};

void weakPtrSubscriberDemo() {
    cout << "\n=== weak_ptr 订阅 ===" << endl;

    SafeEventBus<ClickEvent> bus;

    // 订阅者 1:存在
    auto btn1 = std::make_shared<Button>();
    bus.subscribeWeak(btn1, &Button::onClick);

    // 订阅者 2:临时存在
    {
        auto btn2 = std::make_shared<Button>();
        bus.subscribeWeak(btn2, &Button::onClick);
        bus.publish({10, 20});   // btn1、btn2 都收到
    }
    // btn2 销毁

    cout << "btn2 销毁后:" << endl;
    bus.publish({30, 40});   // 只有 btn1 收到(btn2 自动跳过)
}

这个设计"优雅"在哪:订阅者不需要"手动取消订阅"——对象销毁后,weak_ptr::lock() 自动失败,回调自动跳过。这避免了"忘记取消订阅"导致的悬空。

2.3 "订阅 ID"方案("手动取消"场景)

有些场景"不想用 weak_ptr"——比如"订阅者本身是 static 函数"或"lambda 无捕获"。这时用"订阅 ID":

#include <unordered_map>
#include <cstdint>

template<typename Event>
class IdEventBus {
private:
    using SubscriptionId = uint64_t;
    unordered_map<SubscriptionId, function<void(const Event&)>> subscribers_;
    SubscriptionId nextId_ = 1;

public:
    // 订阅:返回 ID
    SubscriptionId subscribe(function<void(const Event&)> cb) {
        SubscriptionId id = nextId_++;
        subscribers_[id] = std::move(cb);
        return id;
    }

    // 取消订阅:用 ID
    bool unsubscribe(SubscriptionId id) {
        return subscribers_.erase(id) > 0;
    }

    void publish(const Event& event) {
        for (auto& [id, cb] : subscribers_) {
            cb(event);
        }
    }
};

void idSubscriberDemo() {
    cout << "\n=== 订阅 ID ===" << endl;

    IdEventBus<ClickEvent> bus;

    auto id1 = bus.subscribe([](const ClickEvent& e) {
        cout << "订阅者 1: (" << e.x << ", " << e.y << ")" << endl;
    });

    auto id2 = bus.subscribe([](const ClickEvent& e) {
        cout << "订阅者 2: (" << e.x << ", " << e.y << ")" << endl;
    });

    bus.publish({10, 20});

    bus.unsubscribe(id1);
    cout << "取消订阅 1 后:" << endl;
    bus.publish({30, 40});
}

两种方案的"选择":

方案优点缺点适用场景
weak_ptr自动取消订阅者必须用 shared_ptr对象订阅(推荐)
订阅 ID灵活(任意订阅者)需手动取消全局回调、临时订阅

三、并发安全:shared_mutex + 快照

3.1 "多线程"的问题

三个并发场景:

  1. 线程 A 订阅 + 线程 B 发布 → 数据竞争(vector 被修改)
  2. 线程 A 取消订阅 + 线程 B 发布 → 迭代器失效
  3. 线程 A 发布 + 线程 B 发布 → 迭代器失效

“朴素方案”:用 mutex 包裹所有操作:

template<typename Event>
class MutexEventBus {
private:
    vector<function<void(const Event&)>> subscribers_;
    mutable std::mutex mtx_;

public:
    void subscribe(function<void(const Event&)> cb) {
        std::lock_guard<std::mutex> lock(mtx_);
        subscribers_.push_back(std::move(cb));
    }

    void publish(const Event& event) {
        std::lock_guard<std::mutex> lock(mtx_);   // 全程持锁
        for (auto& cb : subscribers_) {
            cb(event);   // 回调执行期间"持锁"!
        }
    }
};

问题:回调执行期间"持锁"——如果回调"很慢"(比如"发网络请求"),所有其他线程"等待"。性能灾难。

3.2 "快照"方案:shared_mutex + 局部拷贝

改进方案:读(发布)用 shared_lock,写(订阅)用 unique_lock;回调执行"不持锁"(用快照)。

#include <shared_mutex>

template<typename Event>
class SnapshotEventBus {
private:
    vector<function<void(const Event&)>> subscribers_;
    mutable std::shared_mutex mtx_;

public:
    void subscribe(function<void(const Event&)> cb) {
        std::unique_lock<std::shared_mutex> lock(mtx_);
        subscribers_.push_back(std::move(cb));
    }

    void publish(const Event& event) {
        // 1. "快照"当前订阅者(持锁时间极短)
        vector<function<void(const Event&)>> snapshot;
        {
            std::shared_lock<std::shared_mutex> lock(mtx_);
            snapshot = subscribers_;   // 拷贝一份
        }

        // 2. "回调执行"(无锁)
        for (auto& cb : snapshot) {
            cb(event);
        }
    }
};

"快照"的核心思路:"读"用 shared_lock(多读并发),"拷贝"后立刻释放锁,回调执行"不持锁"。

这个方案的"性能提升":

场景MutexEventBusSnapshotEventBus
纯读取(无订阅修改)串行(mutex)并发(shared_lock)
回调执行慢全程持锁,严重阻塞无锁执行
回调中"订阅新回调"死锁正常

3.3 “快照"方案的"回调中订阅”

"快照"还有一个隐藏优势:回调中"订阅新回调"是安全的——因为遍历的是"快照",不是"原 vector"。

void snapshotSubscribeDemo() {
    cout << "\n=== 快照 + 回调中订阅 ===" << endl;

    SnapshotEventBus<ClickEvent> bus;

    bus.subscribe([](const ClickEvent& e) {
        cout << "回调 1: " << e.x << endl;
    });

    bus.subscribe([](const ClickEvent& e) {
        cout << "回调 2: " << e.x << endl;
        // 这里"订阅新回调"——快照方案安全
        // (但 lambda 捕获的 bus 是"引用",本示例省略)
    });

    bus.publish({10, 0});   // 两个回调都执行
}

"快照"的代价:每次发布都"拷贝一份订阅者 vector"——如果订阅者很多、发布很频繁,这个拷贝开销不可忽略。

优化:“引用计数 + 版本号”——只在"订阅者被修改"时"重新拷贝"。这是"std::shared_ptr<const vector>"方案的思路(后面"综合实战"用)。


四、异常隔离

4.1 "回调抛异常"的问题

问题:如果某个回调抛异常,publish 会"中断"——后面的回调收不到。

void callbackExceptionDemo() {
    cout << "\n=== 回调异常 ===" << endl;

    SnapshotEventBus<ClickEvent> bus;

    bus.subscribe([](const ClickEvent& e) {
        cout << "回调 1: " << e.x << endl;
    });

    bus.subscribe([](const ClickEvent& e) {
        throw std::runtime_error("回调 2 抛异常");
    });

    bus.subscribe([](const ClickEvent& e) {
        cout << "回调 3: " << e.x << endl;   // 收不到!
    });

    try {
        bus.publish({10, 0});
    } catch (const std::exception& ex) {
        cout << "捕获: " << ex.what() << endl;
    }

    // 问题:回调 2 抛异常后,回调 3 根本没执行
}

4.2 “每个回调独立 try/catch”

解决方案:每个回调"单独 try/catch"——异常"就地处理",不传播。

template<typename Event>
class IsolatedEventBus {
private:
    vector<function<void(const Event&)>> subscribers_;
    mutable std::shared_mutex mtx_;

    // 异常处理:可自定义
    function<void(std::exception_ptr, const Event&)> onError_;

public:
    void subscribe(function<void(const Event&)> cb) {
        std::unique_lock<std::shared_mutex> lock(mtx_);
        subscribers_.push_back(std::move(cb));
    }

    void setErrorHandler(function<void(std::exception_ptr, const Event&)> handler) {
        onError_ = std::move(handler);
    }

    void publish(const Event& event) {
        // 快照
        vector<function<void(const Event&)>> snapshot;
        {
            std::shared_lock<std::shared_mutex> lock(mtx_);
            snapshot = subscribers_;
        }

        // 每个回调"独立隔离"
        for (auto& cb : snapshot) {
            try {
                cb(event);
            } catch (...) {
                // 异常"就地捕获",不影响其他回调
                if (onError_) {
                    onError_(std::current_exception(), event);
                }
            }
        }
    }
};

void isolatedExceptionDemo() {
    cout << "\n=== 异常隔离 ===" << endl;

    IsolatedEventBus<ClickEvent> bus;

    bus.setErrorHandler([](std::exception_ptr eptr, const ClickEvent& e) {
        try {
            std::rethrow_exception(eptr);
        } catch (const std::exception& ex) {
            cout << "回调异常: " << ex.what() 
                 << "(事件 " << e.x << ")" << endl;
        }
    });

    bus.subscribe([](const ClickEvent& e) {
        cout << "回调 1: " << e.x << endl;
    });

    bus.subscribe([](const ClickEvent& e) {
        throw std::runtime_error("回调 2 异常");
    });

    bus.subscribe([](const ClickEvent& e) {
        cout << "回调 3: " << e.x << endl;   // 仍然执行!
    });

    bus.publish({10, 0});
}

"异常隔离"的价值:单个回调的 bug 不会"拖垮"整个事件系统——这在"插件架构""动态加载"场景里至关重要。


五、递归安全

5.1 "回调中触发"的递归问题

问题:回调中"触发同一事件" → 无限递归 → 栈溢出。

void recursivePublishDemo() {
    cout << "\n=== 递归触发 ===" << endl;

    IdEventBus<int> bus;

    bus.subscribe([&bus](const int& n) {
        cout << "回调: " << n << endl;
        if (n < 100) {
            bus.publish(n + 1);   // 递归触发!
        }
    });

    // bus.publish(0);   // 会"递归"直到栈溢出(这里不执行)
    cout << "(不执行递归,仅演示问题)" << endl;
}

"递归"的两个后果:

  1. 栈溢出(如果递归深)
  2. “无限循环”(如果逻辑错误)

5.2 "任务队列"方案

解决方案:回调"不立即执行",而是"加入队列",由"主循环"逐个执行。

#include <deque>

template<typename Event>
class DeferredEventBus {
private:
    vector<function<void(const Event&)>> subscribers_;
    deque<Event> pendingEvents_;
    mutable std::shared_mutex mtx_;
    bool dispatching_ = false;

public:
    void subscribe(function<void(const Event&)> cb) {
        std::unique_lock<std::shared_mutex> lock(mtx_);
        subscribers_.push_back(std::move(cb));
    }

    // 发布:只"加入队列",不立即执行
    void publish(const Event& event) {
        std::unique_lock<std::shared_mutex> lock(mtx_);
        pendingEvents_.push_back(event);
    }

    // 处理所有待处理事件
    void dispatchAll() {
        // 防止"重入"(如果 dispatch 中又调 dispatch)
        if (dispatching_) return;
        dispatching_ = true;

        while (true) {
            // 取出一个事件
            std::optional<Event> event;
            {
                std::unique_lock<std::shared_mutex> lock(mtx_);
                if (pendingEvents_.empty()) break;
                event = std::move(pendingEvents_.front());
                pendingEvents_.pop_front();
            }

            // 回调执行(无锁)
            vector<function<void(const Event&)>> snapshot;
            {
                std::shared_lock<std::shared_mutex> lock(mtx_);
                snapshot = subscribers_;
            }

            for (auto& cb : snapshot) {
                try {
                    cb(*event);
                } catch (...) {
                    // 异常隔离
                }
            }
        }

        dispatching_ = false;
    }
};

"队列"方案的优势:递归触发"变成"队列追加"——不会栈溢出,而是"逐个处理"。

“队列"的"行为变化”:

  • “立即发布” → “延迟发布”(publish 后事件还在队列里)
  • 需要"显式" dispatchAll——这给了"控制权"(可以"每帧处理一次")

六、优先级调度

6.1 "优先级"的需求

问题:“紧急回调”(如"UI 更新")应该"先于"普通回调(如"日志")执行。

解决方案:用 priority_queue 替代 vector。

template<typename Event>
class PriorityEventBus {
private:
    struct Subscription {
        int priority;
        uint64_t sequence;
        function<void(const Event&)> callback;

        bool operator<(const Subscription& other) const {
            // priority_queue 是"大顶堆":优先级大的先执行
            if (priority != other.priority) return priority < other.priority;
            // 同优先级:先订阅的先执行(FIFO)
            return sequence > other.sequence;
        }
    };

    std::priority_queue<Subscription> subscribers_;
    uint64_t nextSequence_ = 0;
    mutable std::shared_mutex mtx_;

public:
    void subscribe(int priority, function<void(const Event&)> cb) {
        std::unique_lock<std::shared_mutex> lock(mtx_);
        subscribers_.push({priority, nextSequence_++, std::move(cb)});
    }

    void publish(const Event& event) {
        // 快照(priority_queue 不能"整体拷贝"迭代,用"临时拷贝")
        std::priority_queue<Subscription> snapshot;
        {
            std::shared_lock<std::shared_mutex> lock(mtx_);
            snapshot = subscribers_;
        }

        while (!snapshot.empty()) {
            auto sub = std::move(const_cast<Subscription&>(snapshot.top()));
            snapshot.pop();
            try {
                sub.callback(event);
            } catch (...) {
                // 异常隔离
            }
        }
    }
};

“优先级"的"实战用例”:

  • UI 更新:priority = 100(必须"立即"响应)
  • 业务逻辑:priority = 50(正常处理)
  • 日志、统计:priority = 10(可"延后")

七、线程池与异步回调

7.1 "线程池"的基本结构

线程池 = “任务队列” + “固定数量的 worker 线程”:

#include <thread>
#include <condition_variable>

class ThreadPool {
private:
    vector<thread> workers_;
    queue<function<void()>> tasks_;
    mutable std::mutex mtx_;
    std::condition_variable cv_;
    bool stop_ = false;

public:
    explicit ThreadPool(size_t numThreads) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers_.emplace_back([this] {
                while (true) {
                    function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(mtx_);
                        cv_.wait(lock, [this] { return stop_ || !tasks_.empty(); });
                        if (stop_ && tasks_.empty()) return;
                        task = std::move(tasks_.front());
                        tasks_.pop();
                    }
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(mtx_);
            stop_ = true;
        }
        cv_.notify_all();
        for (auto& t : workers_) t.join();
    }

    template<typename F>
    void enqueue(F&& task) {
        {
            std::unique_lock<std::mutex> lock(mtx_);
            tasks_.emplace(std::forward<F>(task));
        }
        cv_.notify_one();
    }
};

7.2 “异步事件"的"回调队列”

“异步事件”:事件发布"不阻塞",回调"在线程池里执行":

template<typename Event>
class AsyncEventBus {
private:
    vector<function<void(const Event&)>> subscribers_;
    mutable std::shared_mutex mtx_;
    ThreadPool pool_;

public:
    explicit AsyncEventBus(size_t numThreads) : pool_(numThreads) {}

    void subscribe(function<void(const Event&)> cb) {
        std::unique_lock<std::shared_mutex> lock(mtx_);
        subscribers_.push_back(std::move(cb));
    }

    void publishAsync(const Event& event) {
        // 快照
        vector<function<void(const Event&)>> snapshot;
        {
            std::shared_lock<std::shared_mutex> lock(mtx_);
            snapshot = subscribers_;
        }

        // 提交到线程池
        for (auto& cb : snapshot) {
            pool_.enqueue([cb, event]() {   // 注意:拷贝 lambda 和 event
                try {
                    cb(event);
                } catch (...) {
                    // 异常隔离
                }
            });
        }
    }
};

"异步"的代价:

  • event 要"拷贝"(每个回调一份,或共享 shared_ptr)
  • 回调"不确定何时执行"(取决于线程池)
  • 顺序不保证(多线程执行)

八、综合实战:完整的事件总线

8.1 完整设计

综合所有"解决方案":

  • 类型安全:模板 + shared_ptr 订阅者
  • 生命周期:weak_ptr 检查
  • 并发安全:shared_mutex + 快照
  • 异常隔离:每个回调 try/catch
  • 递归安全:publish + dispatch 分离
  • 优先级:priority_queue

代码如下(示例):

/*-----------------------------------【程序说明】----------------------------
*			 项目命题:   C++基础宝典
*			 代码所属:   瑶池酒剑仙(枫之剑客)
*			     作者:   阿甘
*		     开发时间:   2026/11/19
*			IDE 版 本:   Visual Studio 2026
*		     项目版本:   1.0.0.1
*---------------------------------------------------------------------------*/
//原文链接:https://ganzp1688.blog.csdn.net/?type=blog

#include <functional>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <deque>
#include <queue>
#include <vector>
#include <unordered_map>
#include <typeindex>
#include <any>
#include <iostream>
#include <optional>

// ============================================================
// EventBus:类型安全的"事件总线"
// ============================================================
class EventBus {
private:
    // 单个订阅
    struct Subscription {
        int priority = 50;
        uint64_t sequence = 0;
        std::function<void(const std::any&)> callback;
        std::weak_ptr<void> owner;   // 可选:用于"存活检查"
    };

    // 每种事件类型:一组订阅
    std::unordered_map<std::type_index, std::vector<Subscription>> subscribers_;
    mutable std::shared_mutex mtx_;
    uint64_t nextSequence_ = 0;

    // 延迟队列:用于"递归安全"
    std::deque<std::function<void()>> pendingTasks_;
    bool dispatching_ = false;

public:
    // ========== 订阅 ==========

    // "强引用"订阅(订阅者自己管理生命周期)
    template<typename Event, typename F>
    void subscribe(int priority, F&& callback) {
        std::unique_lock lock(mtx_);
        auto& subs = subscribers_[std::type_index(typeid(Event))];
        subs.push_back({
            priority,
            nextSequence_++,
            [cb = std::forward<F>(callback)](const std::any& e) {
                cb(std::any_cast<const Event&>(e));
            },
            {}
        });
    }

    // "弱引用"订阅(自动检查存活)
    template<typename Event, typename T>
    void subscribeWeak(int priority, std::shared_ptr<T> owner,
                       void (T::*method)(const Event&)) {
        std::unique_lock lock(mtx_);
        auto& subs = subscribers_[std::type_index(typeid(Event))];
        subs.push_back({
            priority,
            nextSequence_++,
            [weak = std::weak_ptr<T>(owner), method](const std::any& e) {
                if (auto sp = weak.lock()) {
                    (sp.get()->*method)(std::any_cast<const Event&>(e));
                }
            },
            owner
        });
    }

    // ========== 发布 ==========

    // 同步发布:立即执行所有回调
    template<typename Event>
    void publish(const Event& event) {
        std::vector<Subscription> snapshot;
        {
            std::shared_lock lock(mtx_);
            auto it = subscribers_.find(std::type_index(typeid(Event)));
            if (it == subscribers_.end()) return;
            snapshot = it->second;   // 拷贝
        }

        // 按优先级排序(priority_queue 是"大顶堆",但 std::sort 更快)
        std::sort(snapshot.begin(), snapshot.end(),
            [](const Subscription& a, const Subscription& b) {
                if (a.priority != b.priority) return a.priority > b.priority;
                return a.sequence < b.sequence;
            });

        // 逐个执行(异常隔离)
        for (auto& sub : snapshot) {
            try {
                sub.callback(event);
            } catch (const std::exception& ex) {
                std::cerr << "[EventBus] 回调异常: " << ex.what() << std::endl;
            } catch (...) {
                std::cerr << "[EventBus] 回调未知异常" << std::endl;
            }
        }
    }

    // 延迟发布:加入队列,稍后执行(递归安全)
    template<typename Event>
    void publishDeferred(Event event) {
        std::unique_lock lock(mtx_);
        pendingTasks_.emplace_back(
            [this, ev = std::move(event)]() {
                publish(ev);
            }
        );
    }

    // 处理所有待执行任务
    void dispatch() {
        if (dispatching_) return;   // 防重入
        dispatching_ = true;

        while (true) {
            std::function<void()> task;
            {
                std::unique_lock lock(mtx_);
                if (pendingTasks_.empty()) break;
                task = std::move(pendingTasks_.front());
                pendingTasks_.pop_front();
            }
            task();
        }

        dispatching_ = false;
    }

    // 清理:取消所有"已销毁"的订阅
    void cleanup() {
        std::unique_lock lock(mtx_);
        for (auto& [type, subs] : subscribers_) {
            subs.erase(
                std::remove_if(subs.begin(), subs.end(),
                    [](const Subscription& s) {
                        return !s.owner.expired() || s.owner.use_count() == 0;
                    }),
                subs.end()
            );
        }
    }
};

// ============================================================
// 测试
// ============================================================
struct ClickEvent { int x, y; };
struct KeyEvent { int key; };

class Button : public std::enable_shared_from_this<Button> {
public:
    std::string name;
    explicit Button(std::string n) : name(std::move(n)) {}

    void handleClick(const ClickEvent& e) {
        std::cout << "[" << name << "] 点击 (" << e.x << ", " << e.y << ")" << std::endl;
    }
};

void fullEventBusDemo() {
    std::cout << "\n╔══════════════════════════════════════════════════════════════╗\n";
    std::cout << "║          综合实战:完整的事件总线                          ║\n";
    std::cout << "╚══════════════════════════════════════════════════════════════╝\n";

    EventBus bus;

    // 1. 普通订阅(高优先级)
    bus.subscribe<ClickEvent>(100, [](const ClickEvent& e) {
        std::cout << "[高优先级] 点击 (" << e.x << ", " << e.y << ")" << std::endl;
    });

    // 2. 普通订阅(低优先级)
    bus.subscribe<ClickEvent>(10, [](const ClickEvent& e) {
        std::cout << "[低优先级] 点击 (" << e.x << ", " << e.y << ")" << std::endl;
    });

    // 3. weak_ptr 订阅(存活检查)
    {
        auto btn = std::make_shared<Button>("确定");
        bus.subscribeWeak<ClickEvent>(50, btn, &Button::handleClick);

        std::cout << "\n=== 按钮存在时发布 ===" << std::endl;
        bus.publish(ClickEvent{10, 20});
    }
    // btn 销毁

    std::cout << "\n=== 按钮销毁后发布 ===" << std::endl;
    bus.publish(ClickEvent{30, 40});

    // 4. 异常隔离
    bus.subscribe<ClickEvent>(50, [](const ClickEvent& e) {
        throw std::runtime_error("测试异常");
    });

    std::cout << "\n=== 异常隔离测试 ===" << std::endl;
    bus.publish(ClickEvent{50, 60});

    // 5. 递归安全(延迟发布)
    bus.subscribe<KeyEvent>(50, [&bus](const KeyEvent& e) {
        std::cout << "[递归] 收到 key " << e.key << std::endl;
        if (e.key < 3) {
            bus.publishDeferred(KeyEvent{e.key + 1});   // 延迟,不递归
        }
    });

    std::cout << "\n=== 递归安全测试 ===" << std::endl;
    bus.publishDeferred(KeyEvent{1});
    bus.dispatch();   // 处理所有"延迟"事件

    // 6. 清理已销毁的订阅
    bus.cleanup();

    std::cout << "\n=== 设计要点 ===" << std::endl;
    std::cout << "1. std::any:类型擦除,存任意事件" << std::endl;
    std::cout << "2. shared_mutex + 快照:并发安全" << std::endl;
    std::cout << "3. weak_ptr:订阅者存活检查" << std::endl;
    std::cout << "4. priority + sequence:优先级 + FIFO" << std::endl;
    std::cout << "5. try/catch:异常隔离" << std::endl;
    std::cout << "6. publishDeferred + dispatch:递归安全" << std::endl;
}

int main() {
    simpleEventBusDemo();
    danglingSubscriberDemo();
    weakPtrSubscriberDemo();
    idSubscriberDemo();
    snapshotSubscribeDemo();
    callbackExceptionDemo();
    isolatedExceptionDemo();
    recursivePublishDemo();
    fullEventBusDemo();
    return 0;
}

8.2 "性能优化"总结

这个实现的"性能瓶颈":

瓶颈原因优化
std::any 拷贝每次发布都"拷贝事件"用"引用/指针"传递
快照拷贝每次发布都"拷贝订阅列表"用 shared_ptr<const vector>
std::function 调用间接调用用"模板参数"替代
type_index 查表每次发布都"查哈希表"用"编译期 ID"

"极致优化"版本(适合"高频事件"):

  • 事件用 const Event& 传递(不拷贝)
  • 订阅者用"索引"而非 std::function(如"函数指针数组")
  • 事件类型用"编译期 ID"(而非 type_index)
  • 避免 std::any(用 std::variant + 编译期分发)

但"极致优化"的代价是"灵活性下降"——大多数场景,"综合版本"已经够用。先 profile,再优化。


九、总结与下一篇预告

9.1 事件系统核心结论

问题结论
事件系统的"三层架构"?Event / Publisher / Subscriber
"订阅者悬空"怎么解决?weak_ptr + lock() 检查
"手动取消订阅"怎么做?“订阅 ID” + unsubscribe(id)
"多线程安全"怎么做?shared_mutex + “快照”
"回调执行中"能"订阅新回调"吗?快照方案"可以"
"回调抛异常"怎么处理?每个回调"独立 try/catch"
"递归触发"怎么解决?“延迟队列” + dispatch
"优先级"怎么实现?priority_queue + 序列号
"异步回调"怎么做?线程池 + 任务队列
事件系统的"性能瓶颈"?快照拷贝、std::function 调用、std::any 拷贝

9.2 八条实战军规

  1. 订阅者用 shared_ptr + weak_ptr——自动"取消订阅"。
  2. 并发安全用 shared_mutex + 快照——"读"并发,"写"独占。
  3. 每个回调"独立 try/catch"——异常隔离。
  4. “递归触发"用"延迟队列”——避免栈溢出。
  5. 高优先级回调"必须"先执行——用 priority_queue。
  6. “回调慢"用"线程池”——异步执行,避免阻塞。
  7. "高频事件"避免 std::any 拷贝——用 const& 传递。
  8. “先能跑,再优化”——profile 后针对性优化。

9.3 练习题

练习1: 实现一个"订阅者取消订阅"的 API:bus.unsubscribe(id),用"订阅 ID"方案。

练习2: 实现一个"线程安全的 EventBus",要求:

  • 支持"多线程订阅/发布"
  • 支持"回调中订阅新回调"
  • 用 shared_mutex 保护

练习3: 实现一个"带超时的回调队列":

  • publish(event, timeout):发布事件,超时后"不再执行"
  • 用 std::chrono + std::optional 实现

练习4: 解释下面的代码有什么问题,如何修复:

std::vector<std::function<void()>> listeners;

void dispatch() {
    for (auto& l : listeners) {
        l();
    }
}

void addListener(std::function<void()> cb) {
    listeners.push_back(cb);
}
// 场景:某个 listener 里调用 addListener

练习5: 实现一个"插件系统":

  • 每个插件 subscribe<Event> 订阅事件
  • 插件"动态加载/卸载"
  • 卸载时"自动取消订阅"(weak_ptr)
  • 用"完整事件总线"实现

9.4 下一篇预告

下一篇聚焦 C++ 异常处理,这是"健壮系统"的核心:

  • try / catch / throw 的基础语法
  • 异常安全的三级保证:基本保证、强保证、不抛出保证
  • RAII 与异常安全:为什么 RAII 是"异常安全"的基础
  • 栈展开(stack unwinding):异常抛出时的"对象销毁顺序"
  • noexcept 的语义与性能:为什么移动构造必须 noexcept
  • 异常规格说明(C++11 前 vs C++17)
  • 自定义异常:继承 std::exception 或"独立异常类"
  • 异常与资源管理:unique_ptr / shared_ptr 如何"自动清理"
  • 异常性能:异常的"零开销"原理与"实际开销"
  • 异常陷阱:catch 顺序、throw 拷贝、析构抛异常
  • 综合实战:一个"异常安全的数据库事务"

异常处理是"C++ 里最容易被低估"的特性——很多人"会用 try/catch",但"写出异常安全的代码"是另一回事。下一篇从"语义"到"实战",把"异常安全"讲透。

敬请期待!

在这里插入图片描述

大家的「关注❤️ + 点赞👍 + 收藏⭐」就是我创作的最大动力!谢谢大家的支持,我们下文见!

🌲 请进入下一专栏: 项目实战合集

🌲 彩蛋壁纸别忘了先看哈!

在这里插入图片描述
在这里插入图片描述

新壁纸(响穷彭蠡之滨)

在这里插入图片描述

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/gzplyx/article/details/171019692

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--