devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++高并发网络架构与实现——第六篇_c++客户端服务器架构

作者：花生_TL007 | 2024-02-29 00:46:19

赞

踩

c++客户端服务器架构

目录

一，将客户端改为多线程

二，为服务器添加多线程处理消息

今日实现任务

  1. 将客户端改为多线程
  2. 为服务器添加多线程处理消息
  3. 添加客户端退出事件，并且对代码进行注解，补充，代码调整
  4. 实现阶段目标，一秒发送200万包，能够稳定处理，并且对代码也进行了优化等

1，客户端架构

即启动多个线程，然后在每个线程中建立客户端，然后与服务器进行连接，进行发送消息的活动。

eg:

之前的方法是在主线程中建立1000个客户端，然后进行连接和发送消息。

现在创立四个线程，然后将1000个客户端分散到四个线程中，每个线程处理250个从而减轻压力，并且提升速度。

2，服务器架构

启动多个线程，在客户端连接之后，将新连接的客户端分配到数量比较少的线程中，然后在每个线程中与客户端进行接收消息的活动。

eg:

之前的方法是在主线程中处理连接后的1000个客户端，然后进行连接和发送消息。

现在创立四个线程，然后将连接的1000个客户端分散到四个线程中，每个线程处理250个达到减轻压力，并且提升速度的目的。

3，整体架构

现在还有待提升的地方就是服务器连接客户端的过程，提升一秒接收客户端的连接数量。

一，将客户端改为多线程

  • EasyTcpClient.hpp
  1. #include "EasyTcpClient.hpp"
  2. #include<thread>
  3. #include<mutex>
  4. bool g_bRun = true;
  5. mutex _mutexx;
  6. void cmdThread()//(EasyTcpClient* client)
  7. {
  8. 	while (1)
  9. 	{
  10. 		char cmdBuf[256] = {};
  11.  
  12. 		cin >> cmdBuf;
  14. 		if (strcmp(cmdBuf, "exit") == 0){
  15. 			g_bRun = false;
  16. 			cout << "退出子线程" << endl;
  17. 			return;
  18. 		}
  19. 		else{
  20. 			cout << "不支持的命令" << endl;
  21. 		}
  22. 	}
  23. }
  24.  
  25. //客户端数量
  26. const int cCount = 100;
  27. //发送线程数量
  28. const int tCount = 4;
  29. //客户端数组
  30. EasyTcpClient* client[cCount];
  31.  
  32. void sendThread(int id)
  33. {
  34. 	{
  35. 		lock_guard<mutex> lock(_mutexx);
  36. 		cout << "thread " << id << " start" << endl;
  37. 	}
  38. 	//四个线程ID
  39. 	int c = cCount / tCount;
  40. 	int begin = (id - 1)*c;
  41. 	int end = id*c;
  42.  
  43. 	for (int i = begin; i < end; i++)
  44. 	{
  45. 		client[i] = new EasyTcpClient();
  46. 	}
  47. 	for (int i = begin; i < end; i++)
  48. 	{
  49. 		client[i]->Connect((char *)"127.0.0.1", 4567); //192.168.247.128   
  50. 	}
  51.  
  52. 	cout << "thread=" << id << "  Connect=" << begin << "  end= " << end << endl;
  53.  
  54.  
  55. 	chrono::milliseconds t(3000);
  56. 	this_thread::sleep_for(t);
  57.  
  58. 	Login login[1];
  59. 	for (int i = 0; i < 10; i++)
  60. 	{
  61. 		strcpy(login[i].userName, "lyd");
  62. 		strcpy(login[i].PassWord, "lydmm");
  63. 	}
  64. 	const int nLen = sizeof(login);
  65. 	int _true = 1;
  66. 	while (g_bRun && _true)
  67. 	{
  68. 		for (int i = begin; i < end; i++)
  69. 		{
  70. 			if (client[i]->SendData(login,nLen) == SOCKET_ERROR)
  71. 			{
  72. 				_true = 0;
  73. 				break;
  74. 			}
  75. 			client[i]->OnRun();
  76. 		}
  77. 	}
  78.  
  79. 	for (int i = begin; i < end; i++)
  80. 	{
  81. 		delete client[i];
  82. 		client[i]->Close();
  83. 	}
  84. 	g_bRun = false;
  85. 	cout << "thread  " << id << "  exit" << endl;
  86. 	
  87. }
  88.  
  89. int main()
  90. {
  91. 	//启动UI线程
  92. 	thread t1(cmdThread);         //启动线程函数
  93. 	t1.detach();
  94.  
  95. 	//启动发送线程
  96. 	for (int n = 0; n < tCount; n++)
  97. 	{
  98. 		thread t1(sendThread, n + 1);
  99. 		t1.detach();
  100. 	}
  101.  
  102. 	while (g_bRun)
  103. 	{
  104. 		Sleep(100);
  105. 	}
  106.  
  107. 	cout << "已退出" << endl;
  108. 	system("pause");
  109. 	return 0;
  110. }
  • MessageHeader.hpp
  1.  
  2. enum CMD
  3. {
  4. 	CMD_LOGIN,       //登入
  5. 	CMD_LOGIN_RESULT,
  6. 	CMD_LOGOUT,      //登出
  7. 	CMD_LOGOUT_RESULT,
  8. 	CMD_NEW_USER_JOIN,      //新的用户加入
  9. 	CMD_ERROR,       //错误
  10. };
  11.  
  12. struct DataHeader
  13. {
  14. 	DataHeader()
  15. 	{
  16. 		dataLength = sizeof(DataHeader);
  17. 		cmd = CMD_ERROR;
  18. 	}
  19. 	short dataLength;
  20. 	short cmd;
  21. };
  22.  
  23. //匹配四个消息结构体
  24. struct Login : public DataHeader
  25. {
  26. 	Login()
  27. 	{
  28. 		dataLength = sizeof(Login);
  29. 		cmd = CMD_LOGIN;
  30. 	}
  31. 	char userName[32];
  32. 	char PassWord[32];
  33. 	//char data[932];
  34. };
  35.  
  36. struct LoginResult : public DataHeader
  37. {
  38. 	LoginResult()
  39. 	{
  40. 		dataLength = sizeof(LoginResult);
  41. 		cmd = CMD_LOGIN_RESULT;
  42. 		result = 0;
  43. 	}
  44. 	int result;
  45. 	//char data[992];
  46. };
  47.  
  48. struct Logout : public DataHeader
  49. {
  50. 	Logout()
  51. 	{
  52. 		dataLength = sizeof(Logout);
  53. 		cmd = CMD_LOGOUT;
  54. 	}
  55. 	char userName[32];
  56. };
  57.  
  58. struct LogoutResult : public DataHeader
  59. {
  60. 	LogoutResult()
  61. 	{
  62. 		dataLength = sizeof(LogoutResult);
  63. 		cmd = CMD_LOGOUT_RESULT;
  64. 		result = 0;
  65. 	}
  66. 	int result;
  67. };
  68.  
  69. struct NewUserJoin :public DataHeader
  70. {
  71. 	NewUserJoin()
  72. 	{
  73. 		dataLength = sizeof(NewUserJoin);
  74. 		cmd = CMD_NEW_USER_JOIN;
  75. 		sock = 0;
  76. 	}
  77. 	int sock;
  78. };
  • client.cpp
  1. #include "EasyTcpClient.hpp"
  2. #include<thread>
  3. #include<mutex>
  4. bool g_bRun = true;
  5. mutex _mutexx;
  6. void cmdThread()//(EasyTcpClient* client)
  7. {
  8. 	while (1)
  9. 	{
  10. 		char cmdBuf[256] = {};
  11.  
  12. 		cin >> cmdBuf;
  14. 		if (strcmp(cmdBuf, "exit") == 0){
  15. 			g_bRun = false;
  16. 			cout << "退出子线程" << endl;
  17. 			return;
  18. 		}
  19. 		else{
  20. 			cout << "不支持的命令" << endl;
  21. 		}
  22. 	}
  23. }
  24.  
  25. //客户端数量
  26. const int cCount = 100;
  27. //发送线程数量
  28. const int tCount = 4;
  29. //客户端数组
  30. EasyTcpClient* client[cCount];
  31.  
  32. void sendThread(int id)
  33. {
  34. 	{
  35. 		lock_guard<mutex> lock(_mutexx);
  36. 		cout << "thread " << id << " start" << endl;
  37. 	}
  38. 	//四个线程ID
  39. 	int c = cCount / tCount;
  40. 	int begin = (id - 1)*c;
  41. 	int end = id*c;
  42.  
  43. 	for (int i = begin; i < end; i++)
  44. 	{
  45. 		client[i] = new EasyTcpClient();
  46. 	}
  47. 	for (int i = begin; i < end; i++)
  48. 	{
  49. 		client[i]->Connect((char *)"127.0.0.1", 4567); //192.168.247.128   
  50. 	}
  51.  
  52. 	cout << "thread=" << id << "  Connect=" << begin << "  end= " << end << endl;
  53.  
  54.  
  55. 	chrono::milliseconds t(3000);
  56. 	this_thread::sleep_for(t);
  57.  
  58. 	Login login[1];
  59. 	for (int i = 0; i < 10; i++)
  60. 	{
  61. 		strcpy(login[i].userName, "lyd");
  62. 		strcpy(login[i].PassWord, "lydmm");
  63. 	}
  64. 	const int nLen = sizeof(login);
  65. 	int _true = 1;
  66. 	while (g_bRun && _true)
  67. 	{
  68. 		for (int i = begin; i < end; i++)
  69. 		{
  70. 			if (client[i]->SendData(login,nLen) == SOCKET_ERROR)
  71. 			{
  72. 				_true = 0;
  73. 				break;
  74. 			}
  75. 			client[i]->OnRun();
  76. 		}
  77. 	}
  78.  
  79. 	for (int i = begin; i < end; i++)
  80. 	{
  81. 		delete client[i];
  82. 		client[i]->Close();
  83. 	}
  84. 	g_bRun = false;
  85. 	cout << "thread  " << id << "  exit" << endl;
  86. 	
  87. }
  88.  
  89. int main()
  90. {
  91. 	//启动UI线程
  92. 	thread t1(cmdThread);         //启动线程函数
  93. 	t1.detach();
  94.  
  95. 	//启动发送线程
  96. 	for (int n = 0; n < tCount; n++)
  97. 	{
  98. 		thread t1(sendThread, n + 1);
  99. 		t1.detach();
  100. 	}
  101.  
  102. 	while (g_bRun)
  103. 	{
  104. 		Sleep(100);
  105. 	}
  106.  
  107. 	cout << "已退出" << endl;
  108. 	system("pause");
  109. 	return 0;
  110. }

二，为服务器添加多线程处理消息

  • CELLTimestamp.hpp
  1. #ifndef CELLTimestamp_hpp_
  2. #define CELLTimestamp_hpp_
  3.  
  4. #pragma once
  5. #include<chrono>
  6. using namespace std::chrono;
  7.  
  8. class CELLTimestamp
  9. {
  10. public:
  11. 	CELLTimestamp()
  12. 	{
  13. 		update();
  14. 	}
  15. 	~CELLTimestamp()
  16. 	{
  17.  
  18. 	}
  19.  
  20. 	void update()
  21. 	{
  22. 		_begin = high_resolution_clock::now();
  23. 	}
  24.  
  25. 	//获取当前秒
  26. 	double getElapsedSecond()
  27. 	{
  28. 		return this->getElapsedTimeInMicroSec() * 0.000001;
  29. 	}
  30. 	//获取毫秒
  31. 	double getElapsedTimeInMilliSec()
  32. 	{
  33. 		return this->getElapsedTimeInMicroSec() * 0.001;
  34. 	}
  35. 	//获取微秒
  36. 	long long getElapsedTimeInMicroSec()
  37. 	{
  38. 		return duration_cast<microseconds>(high_resolution_clock::now() - _begin).count();
  39. 	}
  40. protected:
  41. 	time_point<high_resolution_clock> _begin;
  42. };
  43.  
  44. #endif
  • EasyTcpServer.hpp
  1. #ifndef _EasyTcpServer_hpp_
  2. #define _EasyTcpServer_hpp_
  3.  
  4. #ifdef _WIN32
  5. #define FD_SETSIZE 10240
  6. #define WIN32_LEAN_AND_MEAN
  7. #include<windows.h>
  8. #include<Winsock2.h>
  9. #pragma comment(lib,"ws2_32.lib")
  10. #else
  11. #include<unistd.h>
  12. #include<arpa/inet.h>
  13. #include<string.h>
  14.  
  15. #define SOCKET int
  16. #define INVALID_SOCKET       (SOCKET)(~0)
  17. #define SOCKET_ERROR                 (-1)
  18. #endif
  19.  
  20. #include<iostream>
  21. #include<vector>
  22. #include<thread>
  23. #include<mutex>
  24. #include<atomic>
  25.  
  26. #include"MessageHeader.hpp"
  27. #include"CELLTimestamp.hpp"
  28. using namespace std;
  29.  
  30. //缓冲区最小单元大小
  31. #ifndef RECV_BUFF_SIZE
  32. #define RECV_BUFF_SIZE 10240
  33. #endif
  34.  
  35. //#define _CellServer_THREAD_COUNT 4
  36.  
  37. //客户端数据类型
  38. class ClientSocket
  39. {
  40. public:
  41. 	ClientSocket(SOCKET sockfd = INVALID_SOCKET)
  42. 	{
  43. 		_sockfd = sockfd;
  44. 		memset(_szMsgBuf, 0, sizeof(_szMsgBuf));
  45. 		_lastPos = 0;
  46. 	}
  47.  
  48. 	SOCKET sockfd()
  49. 	{
  50. 		return _sockfd;
  51. 	}
  52.  
  53. 	char *msgBuf()
  54. 	{
  55. 		return _szMsgBuf;
  56. 	}
  57.  
  58. 	int getLastPos()
  59. 	{
  60. 		return _lastPos;
  61. 	}
  62.  
  63. 	void setLastPos(int pos)
  64. 	{
  65. 		_lastPos = pos;
  66. 	}
  67.  
  68. 	//发送数据
  69. 	int SendData(DataHeader *header)
  70. 	{
  71. 		if (header)
  72. 		{
  73. 			return (int)send(_sockfd, (const char *)header, header->dataLength, 0);
  74. 		}
  75. 		return SOCKET_ERROR;
  76. 	}
  77. private:
  78. 	SOCKET _sockfd;
  79. 	//第二缓冲区，消息缓冲区
  80. 	char _szMsgBuf[RECV_BUFF_SIZE * 10];
  81. 	//消息缓冲区的数据尾部位置
  82. 	int _lastPos = 0;
  83. };
  84.  
  85. //网络事件接口
  86. class INetEvent
  87. {
  88. public:
  89. 	//客户端加入事件
  90. 	virtual void OnNetJoin(ClientSocket *pClient) = 0;
  91. 	//客户端离开事件
  92. 	virtual void OnNetLeave(ClientSocket *pClient) = 0;
  93. 	//客户端消息事件
  94. 	virtual void OnNetMsg(ClientSocket *pClient, DataHeader *header) = 0;
  95. private:
  96.  
  97. };
  98.  
  99.  
  100. class CellServer
  101. {
  102. public:
  103. 	CellServer(SOCKET sock = INVALID_SOCKET)
  104. 	{
  105. 		_sock = sock;
  106. 		_pNetEvent = nullptr;
  107. 	}
  108.  
  109. 	~CellServer()
  110. 	{
  111. 		Close();
  112. 		_sock = INVALID_SOCKET;
  113. 	}
  114.  
  115. 	//是否工作中
  116. 	bool isRun()
  117. 	{
  118. 		return _sock != INVALID_SOCKET;
  119. 	}
  120.  
  121. 	void setEventObj(INetEvent *event)
  122. 	{
  123. 		_pNetEvent = event;
  124. 	}
  125.  
  126. 	//关闭Socket
  127. 	void Close()
  128. 	{
  129. 		if (_sock != INVALID_SOCKET)
  130. 		{
  131. #ifdef _WIN32
  132. 			for (int n = (int)_clients.size() - 1; n >= 0; n--)
  133. 			{
  134. 				closesocket(_clients[n]->sockfd());
  135. 				delete _clients[n];
  136. 			}
  137.  
  138. 			//关闭套接字closesocket
  139. 			closesocket(_sock);
  140. 			//-----------
  141. 			//清除Windows socket环境
  142. 			//WSACleanup();
  143. #else
  144. 			for (int n = (int)_clients.size() - 1; n >= 0; n--)
  145. 			{
  146. 				close(_clients[n]->sockfd());
  147. 				delete _clients[n];
  148. 			}
  149. 			//关闭套接字closesocket
  150. 			close(_sock);
  151. #endif
  152. 			_clients.clear();
  153. 		}
  154. 	}
  155.  
  156. 	//int mun = 0;
  157. 	//处理网络消息
  158. 	bool OnRun()
  159. 	{
  160. 		while (isRun())
  161. 		{
  162. 			//从缓冲区中取出客户数据
  163. 			if (_clientsBuff.size() >0)
  164. 			{
  165. 				lock_guard<mutex> lock(_mutex);
  166. 				for (auto pClient : _clientsBuff)
  167. 				{
  168. 					_clients.push_back(pClient);
  169. 				}
  170. 				_clientsBuff.clear();
  171. 			}
  172.  
  173. 			//如果没有需要处理的客户端就跳过
  174. 			if (_clients.empty())
  175. 			{
  176. 				chrono::milliseconds t(1);
  177. 				this_thread::sleep_for(t);
  178. 				continue;
  179. 				//return true;
  180. 			}
  181.  
  182. 			//伯克利套接字
  183. 			fd_set fdRead;
  184. 			//fd_set fdWrite;
  185. 			//fd_set fdExp;
  186.  
  187. 			//清理集合
  188. 			FD_ZERO(&fdRead);
  189. 			//FD_ZERO(&fdWrite);
  190. 			//FD_ZERO(&fdExp);
  191. 			
  192. 			//将描述符(socket)加入集合
  193. 			//FD_SET(_sock, &fdRead);
  194. 			//FD_SET(_sock, &fdWrite);
  195. 			//FD_SET(_sock, &fdExp);
  196.  
  197. 			//将描述符(socket)加入集合
  198. 			SOCKET maxSock = _clients[0]->sockfd();
  199. 			int nn = (int)_clients.size() - 1;
  200. 			for (int n = (int)_clients.size() - 1; n >= 0; n--)
  201. 			{
  202. 				FD_SET(_clients[n]->sockfd(), &fdRead);
  203. 				if (maxSock < _clients[n]->sockfd())
  204. 				{
  205. 					maxSock = _clients[n]->sockfd();
  206. 				}
  207. 			}
  208.  
  209. 			//nfds 是一个整数值，是指fd_set集合中所有描述符（socket）的范围，而不是数量
  210. 			//即是所有文件描述符最大值+1，在Windows中这个参数可以写0
  211.  
  212. 			//添加非阻塞
  213. 			//timeval t = { 1, 0 };
  214.  
  215. 			int ret = select(maxSock + 1, &fdRead, 0, 0, nullptr);
  216.  
  217. 			if (ret < 0)
  218. 			{
  219. 				//cout << "select任务结束  " <<nn<< endl;
  220. 				//Close();
  221. 				continue;
  222. 			}
  223.  
  224. 			for (int n = (int)_clients.size() - 1; n >= 0; n--)
  225. 			{
  226. 				if (FD_ISSET(_clients[n]->sockfd(), &fdRead))
  227. 				{ 
  228. 					if (RecvData(_clients[n]) == -1)
  229. 					{
  230. 						auto iter = _clients.begin() + n;
  231. 						if (iter != _clients.end())
  232. 						{
  233. 							if (_pNetEvent)
  234. 							{
  235. 								_pNetEvent->OnNetLeave(_clients[n]);
  236. 							}
  237. 							///顺序不能变
  238. 							delete _clients[n];
  239. 							_clients.erase(iter);
  240. 						}
  241. 					}
  242. 				}
  243. 			}
  244. 		}
  245. 		return true;
  246. 	}
  247.  
  248. 	//缓冲区
  249. 	char _szRecv[RECV_BUFF_SIZE];// = {};
  250. 	//接收数据 处理粘包哦拆分包
  251. 	int RecvData(ClientSocket* pClient)
  252. 	{
  253. 		//5，接受客户端的请求数据
  254. 		int nLen = (int)recv(pClient->sockfd(), (char*)&_szRecv, RECV_BUFF_SIZE, 0);
  255. 		if (nLen <= 0)
  256. 		{
  257. 			//cout <<pClient->sockfd()<< " 客户端已经退出,任务结束" << endl;
  258. 			return -1;
  259. 		}
  260. 		//将收取到的消息拷贝到消息缓冲区
  261. 		memcpy(pClient->msgBuf() + pClient->getLastPos(), _szRecv, nLen);
  262. 		//消息缓冲区的数据尾部后移
  263. 		pClient->setLastPos(pClient->getLastPos() + nLen);
  264.  
  265. 		//判断消息缓冲区的数据长度大于消息头DataHeader长度
  266. 		while (pClient->getLastPos() >= sizeof(DataHeader))
  267. 		{
  268. 			//这个时候就知道当前消息长度
  269. 			DataHeader *header = (DataHeader*)pClient->msgBuf();
  270. 			//判断消息缓冲区的长度大于消息长度
  271. 			if (pClient->getLastPos() >= header->dataLength)
  272. 			{
  273. 				//消息缓冲区剩余未处理数据的长度
  274. 				int nSize = pClient->getLastPos() - header->dataLength;
  275. 				//处理网络消息
  276. 				OnNetMsg(pClient, header);
  277. 				//将消息缓冲区剩余未处理数据前移
  278. 				memcpy(pClient->msgBuf(), pClient->msgBuf() + header->dataLength, nSize);
  279. 				pClient->setLastPos(nSize);
  280. 			}
  281. 			else{
  282. 				//消息缓冲区剩余数据不够一条完整消息
  283. 				break;
  284. 			}
  285. 		}
  286. 		return 0;
  287. 	}
  288.  
  289. 	//响应网络消息
  290. 	virtual void OnNetMsg(ClientSocket *pClient, DataHeader *header)
  291. 	{
  292. 		_pNetEvent->OnNetMsg(pClient, header);
  293. 	}
  294.  
  295. 	void addClient(ClientSocket *pClient)
  296. 	{
  297. 		lock_guard<mutex> lock(_mutex);
  298. 		//_mutex.lock();
  299. 		_clientsBuff.push_back(pClient);
  300. 		//_mutex.unlock();
  301. 	}
  302. 	
  303. 	void Start()
  304. 	{
  305. 		_thread = thread(mem_fn(&CellServer::OnRun), this);
  306. 	}
  307.  
  308. 	size_t getClientCount()
  309. 	{
  310. 		return _clients.size()+_clientsBuff.size();
  311. 	}
  312. private:
  313. 	SOCKET _sock;
  314. 	//正式客户队列
  315. 	vector<ClientSocket*> _clients;
  316. 	//客户缓冲队列
  317. 	vector<ClientSocket*> _clientsBuff;
  318. 	//缓冲队列的锁
  319. 	mutex _mutex;
  320. 	thread _thread;
  321. 	//网络事件对象
  322. 	INetEvent *_pNetEvent;
  323. };
  324.  
  325.  
  326. class EasyTcpServer:public INetEvent
  327. {
  328. private:
  329. 	SOCKET _sock;
  330. 	//vector<ClientSocket*> _clients;
  331. 	//消息处理对象，内部会创建线程
  332. 	vector<CellServer*> _cellServers;
  333. 	//每秒消息计时
  334. 	CELLTimestamp _tTime;
  335. 	//收到消息计数
  336. public:
  337. 	atomic<int> _recvCount;
  338. 	//客户端计数
  339. 	atomic<int> _clientCount;
  340.  
  341. public:
  342. 	EasyTcpServer()
  343. 	{
  344. 		_sock = INVALID_SOCKET;
  345. 		_recvCount = 0;
  346. 		_clientCount = 0;
  347. 	}
  348.  
  349. 	virtual ~EasyTcpServer()
  350. 	{
  351. 		Close();
  352. 	}
  353.  
  354. 	//初始化Socket
  355. 	SOCKET InitSocket()
  356. 	{
  357. #ifdef _WIN32
  358. 		//启动Windows socket 2.x环境
  359. 		WORD ver = MAKEWORD(2, 2);
  360. 		WSADATA dat;
  361. 		WSAStartup(ver, &dat);
  362. #endif
  363. 		//1，用Socket API建立建立TCP客户端
  364. 		if (_sock != INVALID_SOCKET)
  365. 		{
  366. 			cout << "_sock=" << (int)_sock << "关闭旧连接" << endl;
  367. 			Close();
  368. 		}
  369. 		_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  370.  
  371. 		if (_sock == INVALID_SOCKET)
  372. 		{
  373. 			cout << "建立socket失败" << endl;
  374. 		}
  375. 		else
  376. 		{
  377. 			cout << (int)_sock << " 建立socket成功" << endl;
  378. 		}
  379. 		return _sock;
  380. 	}
  381.  
  382. 	//绑定IP和端口号
  383. 	int Bind(const char *ip, unsigned short port)
  384. 	{
  385. 		//if (_sock != INVALID_SOCKET)
  386. 		//{
  387. 		//    InitSocket();
  388. 		//}
  389. 		//2，bind 绑定用于接受客户端连接的网络接口
  390. 		sockaddr_in _sin = {};
  391. 		_sin.sin_family = AF_INET;
  392. 		_sin.sin_port = htons(port);
  393. #ifdef _WIN32
  394. 		if (ip){
  395. 			_sin.sin_addr.S_un.S_addr = inet_addr(ip);
  396. 		}
  397. 		else{
  398. 			_sin.sin_addr.S_un.S_addr = INADDR_ANY;
  399. 		}
  400. #else
  401. 		if (ip){
  402. 			_sin.sin_addr.s_addr = inet_addr(ip);
  403. 		}
  404. 		else{
  405. 			_sin.sin_addr.s_addr = INADDR_ANY;
  406. 		}
  407. #endif
  408.  
  409.  
  410. 		int ret = ::bind(_sock, (sockaddr*)&_sin, sizeof(_sin));
  411. 		if (SOCKET_ERROR == ret)
  412. 		{
  413. 			cout << (int)_sock << "错误，绑定网络端口失败" << endl;
  414. 		}
  415. 		else
  416. 		{
  417. 			cout << "绑定网络端口成功" << port << endl;
  418. 		}
  419. 		return ret;
  420. 	}
  421.  
  422. 	//监听端口号
  423. 	int Listen(int n)
  424. 	{
  425. 		int ret = listen(_sock, n);
  426. 		if (SOCKET_ERROR == ret)
  427. 		{
  428. 			cout << (int)_sock << " 错误，监听网络端口失败" << endl;
  429. 		}
  430. 		else
  431. 		{
  432. 			cout << (int)_sock << " 监听网络端口成功" << endl;
  433. 		}
  434. 		return ret;
  435. 	}
  436.  
  437. 	//接受客户端连接
  438. 	SOCKET Accept()
  439. 	{
  440. 		//4，accept 等待客户端连接
  441. 		sockaddr_in clientAddr = {};
  442. 		int nAddrlen = sizeof(clientAddr);
  443. 		SOCKET cSock = INVALID_SOCKET;
  444.  
  445. #ifdef _WIN32
  446. 		cSock = accept(_sock, (sockaddr *)&clientAddr, &nAddrlen);
  447. #else
  448. 		cSock = accept(_sock, (sockaddr *)&clientAddr, (socklen_t *)&nAddrlen);
  449. #endif
  450. 		if (INVALID_SOCKET == cSock)
  451. 		{
  452. 			cout << (int)_sock << " 错误，接受到无效的客户端连接" << endl;
  453. 		}
  454. 		else
  455. 		{
  456. 			//NewUserJoin userJoin;
  457. 			//SendDataToAll(&userJoin);
  458. 			//将新客户端分配给客户端数量最少的cellServer
  459. 			addClientToCellServer(new ClientSocket(cSock));
  460. 			//获取IP地址 inet_ntoa(clientAddr.sin_addr)
  461. 		}
  462. 		return _sock;
  463. 	}
  464.  
  465.  
  466. 	void addClientToCellServer(ClientSocket *pClient)
  467. 	{
  468. 		//_clients.push_back(pClient);
  469. 		//查找客户数量最少的CellServer消息处理对象
  470. 		auto pMinServer = _cellServers[0];
  471. 		for (auto pCellServer : _cellServers)
  472. 		{
  473. 			if (pMinServer->getClientCount() > pCellServer->getClientCount())
  474. 			{
  475. 				pMinServer = pCellServer;
  476. 			}
  477. 		}
  478. 		pMinServer->addClient(pClient);
  479. 		OnNetJoin(pClient);
  480. 	}
  481.  
  482.  
  483. 	void Start(int _CellServer_THREAD_COUNT)
  484. 	{
  485. 		for (int n = 0; n < _CellServer_THREAD_COUNT; n++)
  486. 		{
  487. 			auto ser = new CellServer(_sock);
  488. 			_cellServers.push_back(ser);
  489. 			//注册网络事件接收对象
  490. 			ser->setEventObj(this);
  491. 			//启动消息处理线程
  492. 			ser->Start();
  493. 		}
  494. 	}
  495.  
  496. 	//关闭Socket
  497. 	void Close()
  498. 	{
  499. 		if (_sock != INVALID_SOCKET)
  500. 		{
  501. #ifdef _WIN32
  502. 			//for (int n = (int)_clients.size() - 1; n >= 0; n--)
  503. 			//{
  504. 			//	closesocket(_clients[n]->sockfd());
  505. 			//	delete _clients[n];
  506. 			//}
  507.  
  508. 			//关闭套接字closesocket
  509. 			closesocket(_sock);
  510. 			//-------------
  511. 			//清除Windows socket环境
  512. 			WSACleanup();
  513. #else
  514. 			for (int n = (int)_clients.size() - 1; n >= 0; n--)
  515. 			{
  516. 				close(_clients[n]->sockfd());
  517. 				delete _clients[n];
  518. 			}
  519. 			//8，关闭套接字closesocket
  520. 			close(_sock);
  521. #endif
  522. 			//_clients.clear();
  523. 		}
  524. 	}
  525.  
  526. 	//处理网络消息
  527. 	bool OnRun()
  528. 	{
  529. 		if (isRun())
  530. 		{
  531. 			time4msg();
  532. 			//伯克利套接字
  533. 			fd_set fdRead;
  534. 			//fd_set fdWrite;
  535. 			//fd_set fdExp;
  536.  
  537. 			FD_ZERO(&fdRead);
  538. 			//FD_ZERO(&fdWrite);
  539. 			//FD_ZERO(&fdExp);
  540.  
  541. 			FD_SET(_sock, &fdRead);
  542. 			//FD_SET(_sock, &fdWrite);
  543. 			//FD_SET(_sock, &fdExp);
  544.  
  545. 			//nfds 是一个整数值，是指fd_set集合中所有描述符（socket）的范围，而不是数量
  546. 			//即是所有文件描述符最大值+1，在Windows中这个参数可以写0
  547.  
  548. 			//添加非阻塞
  549. 			timeval t = { 0, 10 };
  550.  
  551. 			int ret = select(_sock + 1, &fdRead, 0, 0, &t);  //
  552.  
  553. 			if (ret < 0)
  554. 			{
  555. 				cout << "Accept Select任务结束" << endl;
  556. 				Close();
  557. 				return false;
  558. 			}
  559.  
  560. 			if (FD_ISSET(_sock, &fdRead))
  561. 			{
  562. 				FD_CLR(_sock, &fdRead);
  563. 				Accept();
  564. 				return true;
  565. 			}
  566.  
  567. 			return true;
  568. 		}
  569. 		return false;
  570. 	}
  571.  
  572. 	//是否工作中
  573. 	bool isRun()
  574. 	{
  575. 		return _sock != INVALID_SOCKET;
  576. 	}
  577.  
  578. 	//响应网络消息
  579. 	void time4msg()
  580. 	{
  581. 		auto t1 = _tTime.getElapsedSecond();
  582. 		if (_tTime.getElapsedSecond() >= 1.0)
  583. 		{
  584. 			//cout << "thread   "<<_cellServers.size()<<"   tTime    " << t1 <<"    client    " <<(int)_clients.size()<<"	socket	" << _sock << "	_recvCount	" << _recvCount<< endl;
  585. 			cout << "thread   " << _cellServers.size() << "   tTime    " << t1 << "    client    " << (int)_clientCount << "	socket	" << _sock << "	_recvCount	" << _recvCount << endl;
  586. 			_recvCount = 0;
  587. 			_tTime.update();
  588. 		}
  589. 	}
  590.  
  591. 	//群发消息
  592. 	//void SendDataToAll(DataHeader *header)
  593. 	//{
  594. 	//	for (int n = (int)_clients.size() - 1; n >= 0; n--)
  595. 	//	{
  596. 	//		SendData(_clients[n]->sockfd(), header);
  597. 	//	}
  598. 	//}
  599. 	
  600.  
  601. 	//只会被一个线程调用 安全
  602. 	virtual void OnNetJoin(ClientSocket *pClient)
  603. 	{
  604. 		_clientCount++;
  605. 	}
  606. 	//4 多个线程触发不安全
  607. 	//如果只开启一个cellServer就是安全的
  608. 	virtual void OnNetLeave(ClientSocket *pClient)
  609. 	{
  610. 		_clientCount--;
  611. 		//for (int n = (int)_clients.size() - 1; n >= 0; n--)
  612. 		//{
  613. 		//	if (_clients[n] == pClient)
  614. 		//	{
  615. 		//		auto iter = _clients.begin() + n;
  616. 		//		if (iter != _clients.end())
  617. 		//		{
  618. 		//			_clients.erase(iter);
  619. 		//		}
  620. 		//	}
  621. 		//}
  622. 	}
  623. 	//4 多个线程触发不安全
  624. 	//如果只开启一个cellServer就是安全的
  625. 	virtual void OnNetMsg(ClientSocket *pClient, DataHeader *header)
  626. 	{
  627. 		_recvCount++;
  628. 	}
  629. };
  630.  
  631. #endif
  • MessageHeader.hpp
  1. enum CMD
  2. {
  3. 	CMD_LOGIN,       //登入
  4. 	CMD_LOGIN_RESULT,
  5. 	CMD_LOGOUT,      //登出
  6. 	CMD_LOGOUT_RESULT,
  7. 	CMD_NEW_USER_JOIN,      //新的用户加入
  8. 	CMD_ERROR,       //错误
  9. };
  10.  
  11. struct DataHeader
  12. {
  13. 	DataHeader()
  14. 	{
  15. 		dataLength = sizeof(DataHeader);
  16. 		cmd = CMD_ERROR;
  17. 	}
  18. 	short dataLength;
  19. 	short cmd;
  20. };
  21.  
  22. //匹配四个消息结构体
  23. struct Login : public DataHeader
  24. {
  25. 	Login()
  26. 	{
  27. 		dataLength = sizeof(Login);
  28. 		cmd = CMD_LOGIN;
  29. 	}
  30. 	char userName[32];
  31. 	char PassWord[32];
  32. 	//char data[932];
  33. };
  34.  
  35. struct LoginResult : public DataHeader
  36. {
  37. 	LoginResult()
  38. 	{
  39. 		dataLength = sizeof(LoginResult);
  40. 		cmd = CMD_LOGIN_RESULT;
  41. 		result = 0;
  42. 	}
  43. 	int result;
  44. 	//char data[992];
  45. };
  46.  
  47. struct Logout : public DataHeader
  48. {
  49. 	Logout()
  50. 	{
  51. 		dataLength = sizeof(Logout);
  52. 		cmd = CMD_LOGOUT;
  53. 	}
  54. 	char userName[32];
  55. };
  56.  
  57. struct LogoutResult : public DataHeader
  58. {
  59. 	LogoutResult()
  60. 	{
  61. 		dataLength = sizeof(LogoutResult);
  62. 		cmd = CMD_LOGOUT_RESULT;
  63. 		result = 0;
  64. 	}
  65. 	int result;
  66. };
  67.  
  68. struct NewUserJoin :public DataHeader
  69. {
  70. 	NewUserJoin()
  71. 	{
  72. 		dataLength = sizeof(NewUserJoin);
  73. 		cmd = CMD_NEW_USER_JOIN;
  74. 		sock = 0;
  75. 	}
  76. 	int sock;
  77. };
  • server.cpp
  1. #include"EasyTcpServer.hpp"
  2. #include<thread>
  3.  
  4. class MyServer :public EasyTcpServer
  5. {
  6. public:
  7. 	//只会被一个线程调用 安全
  8. 	virtual void OnNetJoin(ClientSocket *pClient)
  9. 	{
  10. 		_clientCount++;
  11. 		//cout << "client " << pClient->sockfd() << "join" << endl;
  12. 	}
  13. 	//4 多个线程触发不安全
  14. 	//如果只开启一个cellServer就是安全的
  15. 	virtual void OnNetLeave(ClientSocket *pClient)
  16. 	{
  17. 		_clientCount--;
  18. 		//cout << "client " << pClient->sockfd() << "leave" << endl;
  19. 	}
  20. 	//4 多个线程触发不安全
  21. 	//如果只开启一个cellServer就是安全的
  22. 	virtual void OnNetMsg(ClientSocket *pClient, DataHeader *header)
  23. 	{
  24. 		_recvCount++;
  25. 		switch (header->cmd)
  26. 		{
  27. 		case CMD_LOGIN:
  28. 		{
  29. 						  //做数据偏移
  30. 						  Login *login = (Login*)header;
  31. 						  //cout << "收到命令：CMD_LOGIN,  数据长度：" << login->dataLength;
  32. 						  //cout << "  UserName：" << login->userName << "  PassWord：" << login->PassWord << endl;
  33. 						  //忽略判断用户名密码是否正确的过程
  34. 						  LoginResult ret;
  35. 						  pClient->SendData(&ret);
  36. 		}
  37. 			break;
  38. 		case CMD_LOGOUT:
  39. 		{
  40. 						   Login *logout = (Login*)header;
  41. 						   cout << "收到命令：CMD_LOGIN,  数据长度：" << logout->dataLength;
  42. 						   cout << "  UserName：" << logout->userName << endl;
  43. 						   //忽略判断用户名密码是否正确的过程
  44. 						   LogoutResult ret;
  45. 						   //SendData(_cSock, (DataHeader *)&ret);
  46. 		}
  47. 			break;
  48. 		default:
  49. 		{
  50. 				   cout << pClient->sockfd() << "  收到未定义的消息，数据长度  " << header->dataLength;
  51. 				   DataHeader ret;
  52. 				   //SendData(_cSock, (DataHeader *)&ret);
  53. 		}
  54. 			break;
  55. 		}
  56. 	}
  57. private:
  58.  
  59. };
  60. int main()
  61. {
  62. 	MyServer server;
  63. 	server.InitSocket();
  64. 	server.Bind(nullptr, 4567);
  65. 	server.Listen(5);
  66. 	server.Start(4);
  67.  
  68. 	while (server.isRun())
  69. 	{
  70. 		server.OnRun();
  71. 	}
  72.  
  73. 	server.Close();
  74. 	cout << "已退出" << endl;
  75. 	system("pause");
  76. 	return 0;
  77. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/162830
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号