📣📣📣📣📣📣📣📣
✏️作者主页:瑶池酒剑仙
📋 系列专栏: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 "多线程"的问题
三个并发场景:
- 线程 A 订阅 + 线程 B 发布 → 数据竞争(
vector被修改) - 线程 A 取消订阅 + 线程 B 发布 → 迭代器失效
- 线程 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(多读并发),"拷贝"后立刻释放锁,回调执行"不持锁"。
这个方案的"性能提升":
| 场景 | MutexEventBus | SnapshotEventBus |
|---|---|---|
| 纯读取(无订阅修改) | 串行(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;
}
"递归"的两个后果:
- 栈溢出(如果递归深)
- “无限循环”(如果逻辑错误)
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 八条实战军规
- 订阅者用
shared_ptr+weak_ptr——自动"取消订阅"。 - 并发安全用
shared_mutex+ 快照——"读"并发,"写"独占。 - 每个回调"独立
try/catch"——异常隔离。 - “递归触发"用"延迟队列”——避免栈溢出。
- 高优先级回调"必须"先执行——用
priority_queue。 - “回调慢"用"线程池”——异步执行,避免阻塞。
- "高频事件"避免
std::any拷贝——用const&传递。 - “先能跑,再优化”——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技术社区




