C++发布订阅模式

C++发布订阅模式

发布订阅模式主要包含三个部分:消息发布、消息订阅者、消息处理中心。与观察者模式相比多出了消息处理中心模块,这样在结构上可以解耦订阅者与发布者,功能上更加的丰富。

观察者模式

结构设计

  • 有一个消息list,主线程向这个list尾部追加消息,同时另一个子线程从消息list头部不断取出第一个消息
  • 查找消息订阅map,订阅者与消息设计为n:n关系,一个消息可被多个订阅者订阅,因此需依次执行订阅了这个消息的函数
    • 如:Stocks Trade消息需被Suber1和Suber4两个订阅者处理

简单来说就是:EventDeta*就是一个数据,并为之取了一个别名 * Trade,称之为消息。而很多类函数(普通函数也一样的)的正常执行需要这个EventData,因此这个类将其某个函数和EventData通过订阅列表绑定,当这个EventData也即是消息成为消息列表的第一个元素时,就执行和这个EventData绑定的所有类函数。

代码

[知乎]](https://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
#include

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
#include
#include
#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 plist;   // 消息发布列表
    map> sMap;   // 消息订阅map,一个订阅者可订阅多个消息
};

main线程

添加三个消息,并分别添加如顶图所示的订阅者(订阅者4换成订阅者1)

#include
#include
#include
#include 
#include 
#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;
}

你可能感兴趣的:(项目思维,c++,开发语言,算法)