SafeQueue读写示例

#define PROC_MAX 100
#define PROC_MIN 0
enum ErrorCode
{
	ERR_OK = 0,
	ERR_INVALID_DATA,
};
class Message
{
public:
	Message() {}
	~Message() {}
	int proc;
	int content;
}; 

typedef int32_t(*MessageHandler)(Message*);//状态模式，函数指针 每个消息对应不同的处理函数 不使用switch case模式 状态模式更好理解 方便扩展
typedef SafeQueue<Message*> MessageList;   //safequeue见上一篇文章
MessageList m_messages;
MessageHandler m_messageHandlers[PROC_MAX];

void setMessageHandler(int32_t proc, MessageHandler handler)
{
	if (proc<PROC_MIN || proc>PROC_MAX)
		return;
	m_messageHandlers[proc] = handler;
}

int32_t onGetMessage0(Message* msg)
{
	int id = msg->proc;
	cout << "deal msg 0\n";
	/*
	消息处理部分 具体处理每种不同的消息
	*/
	if (false)
	{
		return ERR_INVALID_DATA;
	}
	return ERR_OK;
}
int32_t onGetMessage1(Message* msg)
{
	int id = msg->proc;
	cout << "deal msg 1\n";
	/*
	消息处理部分 具体处理每种不同的消息
	*/
	return ERR_OK;
}
int32_t onGetMessage2(Message* msg)
{
	int id = msg->proc;
	cout << "deal msg 2\n";
	/*
	消息处理部分 具体处理每种不同的消息
	*/
	return ERR_OK;
}
int32_t onGetMessage3(Message* msg)
{
	int id = msg->proc;
	cout << "deal msg 3\n";
	/*
	消息处理部分 具体处理每种不同的消息
	*/
	return ERR_OK;
}
int32_t onGetMessage4(Message* msg)
{
	int id = msg->proc;
	cout << "deal msg 4\n";
	/*
	消息处理部分 具体处理每种不同的消息
	*/
	return ERR_OK;
}

void initMessageHandler()
{
	//初始化 每个消息的处理函数
	setMessageHandler(0, &onGetMessage0);
	setMessageHandler(1, &onGetMessage1);
	setMessageHandler(2, &onGetMessage2);
	setMessageHandler(3, &onGetMessage3);
	setMessageHandler(4, &onGetMessage4);
	/*
	每有新消息 添加消息协议号以及对应的处理函数
	*/
}

MessageHandler getMessageHandler(int32_t proc)
{
	if (proc>= PROC_MIN && proc<=PROC_MAX)
		return m_messageHandlers[proc];
	return NULL;
}
void checkMessage()
{
	Message* msg = NULL;
	while ((msg = m_messages.pop()) != NULL)
	{
		int proc = msg->proc;
		if (proc<PROC_MIN || proc>PROC_MAX)
		{
			delete msg;
			return;
		}
		MessageHandler handler = m_messageHandlers[proc];
		if (handler != NULL)
		{
			(*handler)(msg);//handler就是一个函数指针 调用对应的处理函数
		}
		delete msg;					//处理完后 delete对应的消息。 后续用消息池来处理
	}
}
void checkLoop()
{
	bool m_running = true;
	while (m_running)
	{
		checkMessage();
		Sleep(10);
	}
}
void writeLoop()
{
	int i = 0;
	while (true)
	{
		if (i > 4)
			i = 0;
		Message* msg = new Message();//现在采取的方案是 不停地new新的消息 后续用消息池来处理
		msg->proc = i;
		msg->content = i;
		i++;		
		m_messages.push(msg);
		Sleep(100);					//读写速度可以控制，如果读的速度比写慢 那么safequeue消息队列就会越来越大
	}
}

class ReadThread :public SwyThread
{
public:
	ReadThread() {}
	~ReadThread() {}
protected:
	virtual void run();
};
void ReadThread::run()
{
	checkLoop();
	join();
}
class WriteThread :public SwyThread
{
public:
	WriteThread() {}
	~WriteThread() {}
protected:
	virtual void run();
};
void WriteThread::run()
{
	writeLoop();
	join();
}

int main()
{
	initMessageHandler();
	ReadThread* a = new ReadThread();
	WriteThread* b = new WriteThread();
	a->start();
	b->start();
}