Linux下多线程处理消息队列+epoll实现的帧同步游戏服务器

在原来服务器的基础之上加了多线程处理提高效率，同时将使用数组的地方换成了动态类存分配（应该不会内存泄漏）。四个线程处理消息队列的消息然后放到待发送的队列里面，主线程每帧发送一次消息，发送完了delete指针。后面我担心主线程往消息队列里面加东西的时候跟四个线程抢消息队列可能会耗时比较久于是加了个辅助队列和辅助线程，这样主线程就只用跟辅助线程抢了（不知道有没有一点用）

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdint>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <unordered_map>

#include <unistd.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

#include "GameMessage.pb.h"

#define IMPORT_USER
#include "User.h"
#include "SQLTool.h"

#include <pthread.h>

using namespace std;
const int MAXPTHREADCOUNT = 4;
struct MessageNode
{
   
    int iClient;
    uint8_t iLen;
    uint8_t iType;
    uint8_t *PointerBuffer;
    MessageNode()
    {
   
        iClient = 0;
        iLen = 0;
        iType = 0;
        PointerBuffer = nullptr;
    }
};

queue<MessageNode *> MessageQueue;
pthread_mutex_t mutex_MessageQueue;

queue<MessageNode *> supMessageQueue; //辅助队列
pthread_mutex_t mutex_supMessageQueue;

const int MaxClient = 1001;
const int MaxEvents = 20000;
const int MaxMessageQueue = 100000;
int ClientCount = 0;
bool isBegin = false;

//客户端号与fd对应
std::unordered_map<int, int> FdToClientID;
int ClientIDToFd[MaxClient];
bool isClientLogin[MaxClient];

uint8_t Buffer[MaxClient][200];

uint8_t Size[MaxClient];
uint8_t MessageType[MaxClient];
uint8_t MessageLen[MaxClient];

uint32_t NowLoginCount = 0;

int iFrameCount = 0;
int iQueueLen = 0;
uint8_t *BufferFrameQueue[MaxMessageQueue];
uint8_t BufferEffectiveSize[MaxMessageQueue];
pthread_mutex_t mutex_BufferFrameQueue;

enum class MType
{
   
    RegisteredRequest = 1,
    RegisteredRespond,
    LoginRequest,
    LoginRespond,
    GameBegin,
    ActionRequest,
    PlayerAction,
    MoveRequest,
    PlayerMove,
    SetUserInfo,
    SetUserInfoRespond,
    GetUserInfo,
    GetUserInfoRespond,
};

inline void Init()
{
   
    InitUserInfo();

    memset(Size, 0, sizeof(Size));

    memset(MessageType, 0, sizeof(MessageType));

    memset(MessageLen, 0, sizeof(MessageLen));

    memset(isClientLogin, false, sizeof(isClientLogin));

    memset(ClientIDToFd, -1, sizeof(ClientIDToFd));

    iFrameCount = 0;
    iQueueLen = 0;

    pthread_mutex_init(&mutex_MessageQueue, NULL);
    pthread_mutex_init(&mutex_BufferFrameQueue, NULL);
    pthread_mutex_init(&mutex_supMessageQueue, NULL);

    printf("Init Done\n");
}

inline void SendAll(uint8_t *netMessage, uint32_t SumLen)
{
   
    for (int ID = 1; ID <= ClientCount; ID += 1)
    {
   
        if (ClientIDToFd[ID] < 0)
        {
   
            continue;
        }
        if (isClientLogin[ID]) // DANGER
        {
   
            send(ClientIDToFd[ID], netMessage, SumLen, 0);
        }
    }
}

inline void FrameQueue_SendAllMessages()
{
   
    if (iQueueLen == 0)
    {
   
        //处理没有消息的时候
    }
    pthread_mutex_lock(&mutex_BufferFrameQueue);
    for (int i = 0; i < iQueueLen; i++)
    {
   
        for (int ID = 1; ID <= ClientCount; ID += 1)
        {
   
            if (ClientIDToFd[ID] < 0)
            {
   
                continue;
            }
            if (isClientLogin[ID]) // DANGER
            {
   
                send(ClientIDToFd[ID], BufferFrameQueue[i], BufferEffectiveSize[i], 0);
            }
        }
        if (BufferFrameQueue[i])
        {
   
            delete BufferFrameQueue[i];
            BufferFrameQueue[i] = nullptr;
        }
    }
    iQueueLen = 0;
    pthread_mutex_unlock(&mutex_BufferFrameQueue);
}

inline void ProcessEvent(MessageNode *mesNode)
{
   
    printf("处理%d类型\n",static_cast<MType>(mesNode->