C++发布订阅模式
发布订阅模式主要包含三个部分：消息发布、消息订阅者、消息处理中心。与观察者模式相比多出了消息处理中心模块，这样在结构上可以解耦订阅者与发布者，功能上更加的丰富。
结构设计
- 有一个消息list，主线程向这个list尾部追加消息，同时另一个子线程从消息list头部不断取出第一个消息
- 查找消息订阅map，订阅者与消息设计为n:n关系，一个消息可被多个订阅者订阅，因此需依次执行订阅了这个消息的函数
- 如：Stocks Trade消息需被Suber1和Suber4两个订阅者处理
简单来说就是：EventDeta*就是一个数据，并为之取了一个别名 * Trade，称之为消息。而很多类函数（普通函数也一样的）的正常执行需要这个EventData，因此这个类将其某个函数和EventData通过订阅列表绑定，当这个EventData也即是消息成为消息列表的第一个元素时，就执行和这个EventData绑定的所有类函数。
代码
[知乎]](zhuanlan.zhihu.com/p/484171260)
消息发布
EventData.h:
/*
定义有哪些消息、消息对应的数据
当想要发自己的消息，可以在这里进行添加
*/
// 消息句柄用于标识消息
char * event_data1 = "Stocks Trade";
// 消息主体，可做为订阅者的入参，以对此消息进行处理
struct EventData1
{
int e = 0;
};
char * event_data2 = "Bonds Trade";
struct EventData2
{
char * i = "receiver";
};
char * event_data3 = "Funds Trade";
struct EventData3
{
EventData1 data1;
EventData2 data2;
};
消息订阅者
EventSuber.h: 订阅者消息处理函数一般接收两个参数，一个是自己的参数，一个是传过来的消息
这里可以不申明类，直接写三个消息处理函数也可以
#include"EventData.h"
#include<iostream>
#include<string>
using namespace std; // string是标准卡函数
/*订阅消息处理模块 3个 */
class Subscriber1
{
public:
// 利用静态成员函数,保留上一次消息处理结果
// 不能访问非静态成员变量与非静态成员函数 => 传这个类的指针 void* _this
// 强转_this指针，调用此类的成员函数、成员变量 _this=&(Subscriber1实例)
// 给这个订阅器传一个消息
static void HandleReceiveEvent (void * _this, void * data)
{
Subscriber1 * th = (Subscriber1 *)_this;
EventData1* d = (EventData1 *)data;
d->e += th->_data;
printf("%s, data:%d \n",__FUNCTION__,d->e);
}
int _data = 10;
};
class Subscriber2
{
public:
static void HandleReceiveEvent (void * _this, void * data)
{
Subscriber2 * th = (Subscriber2 *)_this;
EventData2* d = (EventData2 *)data;
string str(d->i);
str += th->_data;
printf("%s, data:%s \n",__FUNCTION__,str.c_str());
}
char * _data = " Subscriber 2";
};
class Subscriber3
{
public:
static void HandleReceiveEvent (void * _this, void * data)
{
Subscriber3 * th = (Subscriber3 *)_this;
EventData3* d = (EventData3 *)data;
d->data1.e += th->_data1;
string str(d->data2.i);
str += th->_data2;
printf("%s, data:%d , %s \n",__FUNCTION__,d->data1.e,str.c_str());
}
int _data1 = 30;
char * _data2 = " Subscriber 3";
};
消息处理中心
EventDeal.h: 开启一个子线程，不断去消息list取消息，并将该消息将由所有订阅者进行处理
#include<pthread.h>
#include<map>
#include<list>
#include "EventSuber.h"
/*消息处理中心*/
class EventMsgCentre
{
public:
typedef void(*HandleEvent)(void * , void *);
/* 订阅消息节点 */
// 消息处理函数设置两个入参：第一个_this指针是订阅器者，第二个是消息EventData
// HandleReceiveEvent(suber,msg)形式
struct EventSubscriberNode
{
void * _this; // 只是普通的指针变量
HandleEvent func; // 函数指针，func无返回类型，且双入参都为void*
};
/* 发布消息节点 */
struct EventPublishNode
{
char * event;
void * data;
};
public:
// 初始化消息发布、订阅锁
EventMsgCentre()
{
pthread_mutex_init(&_mutexSubscriber, nullptr);
pthread_mutex_init(&_mutexPublish, nullptr);
}
// 释放锁空间
~EventMsgCentre()
{
pthread_mutex_destroy(&_mutexPublish);
pthread_mutex_destroy(&_mutexSubscriber);
}
// 订阅消息 =》 订阅map追加元素
void SubscriberEvent(char * event, EventSubscriberNode node)
{
pthread_mutex_lock(&_mutexSubscriber);
sMap[event].push_back(node);
pthread_mutex_unlock(&_mutexSubscriber);
}
// 删除消息订阅
void releaseSubscriberEvent(char * event, EventSubscriberNode node)
{
pthread_mutex_lock(&_mutexSubscriber);
auto it = sMap.find(event); // 订阅map中找到这个消息的订阅列表
if(it != sMap.end())
{
for(auto ite = it->second.begin(); ite != it->second.end(); )
{
// 删除这个消息对应订阅列表的某个订阅
if(ite->_this == node._this && ite->func == node.func)
{
ite = it->second.erase(ite);
}
else
{
++ite;
}
}
}
pthread_mutex_unlock(&_mutexSubscriber);
}
// 发布消息，往消息列表添加一个消息节点
void PublishEvent(char * event, void *data)
{
EventPublishNode node;
node.event = event;
node.data = data;
pthread_mutex_lock(&_mutexPublish);
plist.push_back(node);
pthread_mutex_unlock(&_mutexPublish);
}
/* 消息处理中心 */
static void *EventProcess(void * _this)
{
EventMsgCentre * th = (EventMsgCentre *)_this;
while (1)
{
EventPublishNode cur {nullptr, nullptr}; // 申明消息
pthread_mutex_lock(&th->_mutexPublish); // 消息发布锁
// 取出第一个消息
if (th->plist.empty())
{
pthread_mutex_unlock(&th->_mutexPublish);
continue;
}
cur = th->plist.front();
th->plist.pop_front();
pthread_mutex_unlock(&th->_mutexPublish);
// 消息订阅锁
// 找到这个消息对应的订阅
pthread_mutex_lock(&th->_mutexSubscriber);
auto it = th->sMap.find(cur.event);
if(it != th->sMap.end())
{
for(auto ite = it->second.begin(); ite != it->second.end(); ++ite)
{
ite->func(ite->_this, cur.data); // 执行所有订阅者的消息动作
}
}
pthread_mutex_unlock(&th->_mutexSubscriber);
}
}
// 创建线程
void theardProc()
{
/*
1.向调用者传递子线程的线程号
2.线程属性设置，一个结构体，包括线程优先级，线程栈大小
3.指定子线程允许的函数，需要一个函数指针
4.子线程运行的函数参数值
*/
int ret = pthread_create(&pt_id, nullptr, EventProcess, this);
}
public:
pthread_mutex_t _mutexSubscriber; // 消息订阅互斥锁
pthread_mutex_t _mutexPublish; // 消息发布互斥锁
pthread_t pt_id; // 线程id
list<EventPublishNode> plist; // 消息发布列表
map<char *, list<EventSubscriberNode>> sMap; // 消息订阅map,一个订阅者可订阅多个消息
};
main线程
添加三个消息，并分别添加如顶图所示的订阅者（订阅者4换成订阅者1）
#include<iostream>
#include<map>
#include<list>
#include <windows.h>
#include <process.h>
#include"EventDeal.h"
/* 测试。 */
int main()
{
EventMsgCentre eveMsg; /* 初始化 */
eveMsg.theardProc(); /* 启线程 */
/* 订阅消息 */
Subscriber1 ber;
ber._data = 100;
EventMsgCentre::EventSubscriberNode node1;
// 节点的_this就是一个订阅器
node1._this = &ber;
// 节点的函数指针就是订阅器的HandleReceiveEvent
node1.func = Subscriber1::HandleReceiveEvent;
eveMsg.SubscriberEvent(event_data1, node1); // 为消息1("Stocks Trade")添加一个订阅器1
// 由于消息2和消息3不能直接转换成消息1，所以给消息1添加了一个重复的订阅者1
eveMsg.SubscriberEvent(event_data1, node1);
Subscriber2 ber2;
ber2._data = " Subscriber2_200";
EventMsgCentre::EventSubscriberNode node2;
node2._this = &ber2;
node2.func = Subscriber2::HandleReceiveEvent;
eveMsg.SubscriberEvent(event_data2, node2);
Subscriber3 ber3;
ber3._data1 = 300;
ber3._data2 = " Subscriber3_300";
EventMsgCentre::EventSubscriberNode node3;
node3._this = &ber3;
node3.func = Subscriber3::HandleReceiveEvent;
eveMsg.SubscriberEvent(event_data3, node3);
/* 发布消息 */
EventData1 d1{1};
eveMsg.PublishEvent(event_data1, &d1);
EventData2 d2 {"event_data2"};
eveMsg.PublishEvent(event_data2, &d2);
EventData3 d3 {3,"event_data3"};
eveMsg.PublishEvent(event_data3, &d3);
// Sleep(1000); // 休眠一秒,主线程退出，子线程消息处理函数随之退出
// eveMsg.~EventMsgCentre();
while(1){} // 等待EventProcess执行完成
return 0;
}
