聊天服务器——消息系统

最新推荐文章于 2024-08-20 17:31:19 发布

qq_44862488

最新推荐文章于 2024-08-20 17:31:19 发布

阅读量536

点赞数 10

文章标签：服务器 c++ 运维

本文链接：https://blog.csdn.net/qq_44862488/article/details/140403687

版权

消息系统

前缀知识

std::unique_lock

std::mutex m_mtItems；
std::unique_lock<std::mutex> guard(m_mtItems);

std::unique_lock 是 C++11 提供的一个用于管理互斥锁的类，它提供了更灵活的锁管理功能，适用于各种多线程场景。

（1）自动加锁和解锁

{
    std::unique_lock<std::mutex> lock(mutex); // 自动加锁
    // 临界区代码
} // 自动解锁

使用 std::unique_lock 创建的对象，当其生命周期结束时（通常是在大括号的作用域结束时），会自动解锁互斥锁，以确保互斥锁在不再需要时被释放。大括号是自己声明的。

（2）手动加锁和解锁

std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
lock.lock();   // 手动加锁
// 临界区代码
lock.unlock(); // 手动解锁

你可以使用 lock() 手动加锁，然后在互斥锁保护的临界区内执行代码，最后使用 unlock() 手动解锁。这种方式可以让你更灵活地控制锁的生命周期。

（3）尝试加锁

std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
if (lock.try_lock()) {
    // 锁成功获取，执行临界区代码
    lock.unlock();
} else {
    // 锁不可用，执行其他逻辑
}

std::unique_lock 还提供了 try_lock() 方法，用于尝试加锁，如果锁不可用，则返回 false，如果锁成功获取，则返回 true。

（4）配合条件变量使用

condition_variable（条件变量）是 C++11 中提供的一种多线程同步机制，它允许一个或多个线程等待另一个线程发出的通知，以便能够有效地进行线程同步。

条件变量（std::condition_variable）需要与 std::unique_lock 一起使用，以实现线程的等待和通知机制。

std::unique_lock<std::mutex> lck(mutex);
while (!condition) {
    conditionVariable.wait(lock); // 等待条件满足并释放锁
}
// 条件满足，重新获取锁并继续执行

std::lock_guard

std::mutex m;
void worker()
{
    std::lock_guard<std::mutex> lg(m);  // lock_guard 方式上锁
    std::cout << "worker thread is running..." << std::endl;
    // 这里可以写一些需要互斥保护的代码
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "worker thread is done." << std::endl;
}  // lock_guard 不支持手动解锁，会在此自动释放锁

std::condition_variable

std::condition_variable，是C++11提供的条件变量，可用于同时阻塞一个线程或多个线程。一般的，生产者线程利用支持std::mutex的std::lock_guard/std::unique_lock修改共享变量后，并通知condition_variable。消费者线程获取同一个std::mutex(std::unique_lock所持有)，并调用std::condition_variable的wait, wait_for, or wait_until。wait操作会释放互斥量，同时挂起该线程。当条件变量收到通知、超时到期或发生虚假唤醒时，线程被唤醒，互斥量也被原子地重新获取。需要注意的是，如果是虚假唤醒，线程应该检查条件并继续等待，以保证业务的正确性。

condition_variable 常用成员函数:
- wait：阻塞当前线程直到条件变量被唤醒
- notify_one：通知一个正在等待的线程
- notify_all：通知所有正在等待的线程

使用 wait 必须搭配 std::unique_lock<std::mutex> 一起使用

#include <iostream>
#include <thread>
#include <functional>
#include <mutex>
#include <condition_variable>
using namespace std::placeholders;
class Application {    
    std::mutex m_mutex;    
    std::condition_variable m_condVar;    
    bool m_bDataLoaded;public:
    
    Application() 
    {
        m_bDataLoaded = false;
    }    
    
    void loadData() 
    {        
            //使该线程sleep 1秒
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));        
        std::cout << "Loading Data from XML" << std::endl;        //锁定数据
        std::lock_guard<std::mutex> guard(m_mutex);        //flag设为true，表明数据已加载
        m_bDataLoaded = true;        //通知条件变量
        m_condVar.notify_one();
    }    
    
    bool isDataLoaded() 
    {        
             return m_bDataLoaded;
    }    
    
    void mainTask()
    {        
            std::cout << "Do some handshaking" << std::endl;        //获取锁
        std::unique_lock<std::mutex> mlock(m_mutex);        //开始等待条件变量得到信号
        //wait()将在内部释放锁，并使线程阻塞
        //一旦条件变量发出信号，则恢复线程并再次获取锁
        //然后检测条件是否满足，如果条件满足，则继续，否则再次进入wait
        m_condVar.wait(mlock, std::bind(&Application::isDataLoaded, this));        
        std::cout << "Do Processing On loaded Data" << std::endl;
    }
    
};

int main() {
    Application app;    
    std::thread thread_1(&Application::mainTask, &app);    
    std::thread thread_2(&Application::loadData, &app);
    thread_2.join();
    thread_1.join();    return 0;
}

SendMsg

HandleRegister

把业务数据发送出去。

void CSendMsgThread::HandleRegister(const CRegisterRequest* pRegisterRequest)

提取出pRegisterRequest里的数据，然后使用m_SocketClient->Send(outbuf);

把数据发送出去

void CSendMsgThread::HandleRegister(const CRegisterRequest* pRegisterRequest)
{
    if (pRegisterRequest == NULL)
        return;

    char szRegisterInfo[256] = { 0 };
    sprintf_s(szRegisterInfo,
                256,
                "{\"username\": \"%s\", \"nickname\": \"%s\", \"password\": \"%s\"}",
                pRegisterRequest->m_szAccountName,
                pRegisterRequest->m_szNickName,
                pRegisterRequest->m_szPassword);

    std::string outbuf;
    yt::BinaryWriteStream3 writeStream(&outbuf);
    writeStream.Write(msg_type_register);
    writeStream.Write(m_seq);
    std::string data = szRegisterInfo;
    writeStream.Write(data.c_str(), data.length());
    writeStream.Flush();

    CIULog::Log(LOG_NORMAL, __FUNCSIG__, "Request register: Account=%s, Password=*****, nickname=%s.", pRegisterRequest->m_szAccountName, pRegisterRequest->m_szPassword, pRegisterRequest->m_szNickName);

    m_SocketClient->Send(outbuf);
}

void CSendMsgThread::HandleLogon(const CLoginRequest* pLoginRequest)
void CSendMsgThread::HandleUserBasicInfo(const CUserBasicInfoRequest* pUserBasicInfo)
void CSendMsgThread::HandleGroupBasicInfo(const CGroupBasicInfoRequest* pGroupBasicInfo)
void CSendMsgThread::HandleFindFriendMessage(const CFindFriendRequest* pFindFriendRequest)
。。。。。。。

凡是这种Handle类型的函数，都是去使用

m_SocketClient->Send(outbuf);

把数据发送出去

Run

void CSendMsgThread::Run()
{
    while (!m_bStop)
    {
        CNetData* lpMsg;
        {
            std::unique_lock<std::mutex> guard(m_mtItems);
            while (m_listItems.empty()) 
            {
                if (m_bStop)
                    return;

                m_cvItems.wait(guard);  //会在这里一直wait，直到别的地方m_cvItems.notify_one()
            }

            lpMsg = m_listItems.front();
            m_listItems.pop_front();
        }   //大括号结束，guard就会自动析构

        HandleItem(lpMsg);
    }
}

Stop

void CSendMsgThread::Stop()
{
    m_bStop = true;
    m_cvItems.notify_one();     //主要是让Run里的m_cvItems.wait(guard)结束
}

AddItem

假如一开始m_listItems为空，addItem之后不为空，同时m_cvItems.notify_one()。这样Run里的

m_cvItems.wait(guard)就会解锁，同时进入while (m_listItems.empty()) 。

void CSendMsgThread::AddItem(CNetData* pItem)
{
    std::lock_guard<std::mutex> guard(m_mtItems);
    m_listItems.push_back(pItem);
    m_cvItems.notify_one();        //主要是让Run里的m_cvItems.wait(guard)结束
}

HandleItem

pNetData转化成对应的业务数据，并进行处理

void CSendMsgThread::HandleItem(CNetData* pNetData)
{
   switch(pNetData->m_uType)
   {
    case NET_DATA_REGISTER:
       HandleRegister((const CRegisterRequest*)pNetData);
       break;

    case NET_DATA_LOGIN:
       HandleLogon((const CLoginRequest*)pNetData);
       break;
    ......
    
    }
}

HandleSentChatMessage

BOOL CSendMsgThread::HandleSentChatMessage(const CSendChatMessage* pSentChatMessage)
{
        if(pSentChatMessage == NULL)
        return FALSE;

    CMsgItem* lpMsgItem = pSentChatMessage->m_pMsgItem;
    if (lpMsgItem == NULL)
    {
        return FALSE;
    }
    
    BOOL bRet = FALSE;
    switch (lpMsgItem->m_nType)
    {
    case FMG_MSG_TYPE_BUDDY:        // 好友消息
        {
            bRet = SendBuddyMsg(lpMsgItem);
            if (!bRet)
                ::OutputDebugString(_T("发送好友消息失败\n"));
        }
        break;
    case FMG_MSG_TYPE_GROUP:        // 群消息
        {
            bRet = SendBuddyMsg(lpMsgItem);
            if (!bRet)
                ::OutputDebugString(_T("发送群消息失败\n"));
        }
        break;
    case FMG_MSG_TYPE_MULTI:        //群发消息
        {
            bRet = SendMultiMsg(lpMsgItem);
            if (!bRet)
                ::OutputDebugString(_T("群发消息失败\n"));
        }
        break;

    case FMG_MSG_TYPE_SESS:     // 群成员消息
        {
            bRet = SendSessMsg(lpMsgItem);
            if (!bRet)
                ::OutputDebugString(_T("发送群成员消息失败\n"));
        }
        break;
    }
    
    if(bRet)
        delete lpMsgItem;
    
    return bRet;

}