服务器和客户端简单的使用select网络模型（三）
在二的基础上收发数据进行了改进（数据接收增加了二次缓存），提供吞吐量。
Server部分：一共4个文件（server.cpp,EasyTcpServer.hpp，MessageHeader.hpp和CELLTimestamp.hpp）
server.cpp：
#include"EasyTcpServer.hpp" #include<thread> bool g_bRun = true; void CmdThread() { while (true) { char cmdBuf[256] = {}; scanf("%s", cmdBuf); if (0 == strcmp(cmdBuf, "exit")) { g_bRun = false; printf("退出cmdThread线程\n"); break; } else printf("不支持的命令。 \n"); } } int main() { EsayTcpServer server; server.initSocket(); server.Bind(nullptr, 10000); server.Listen(100); std::thread t1(CmdThread); t1.detach(); while (g_bRun) { server.OnRun(); } server.Close(); printf("已退出\n"); return 0; }
EasyTcpServer.hpp：
#ifndef _EASY_TCP_SERVER_HPP_ #define _EASY_TCP_SERVER_HPP_ #define _AFXDLL #ifdef _WIN32 #define FD_SETSIZE 5000 #include"afx.h" #include<windows.h> #include "WinSock2.h" #else #include<unistd.h> #include<arpa/inet.h> #include<string.h> #define SOCKET int #define INVALID_SOCKET (SOCKET)(~0) #define SOCKET_ERROR (-1) #endif #include<iostream> #include<vector> #include<stdlib.h> #include"MessageHeader.hpp" #include "CELLTimestamp.hpp" #define RECV_BUFF_SIZE 10240 class ClientSocket { public: ClientSocket(SOCKET sockfd = INVALID_SOCKET) { _sockfd = sockfd; ZeroMemory(_szMsgBuf, sizeof(_szMsgBuf)); _lastPos = 0; } ~ClientSocket() { } SOCKET sockfd() { return _sockfd; } char * msgBuf() { return _szMsgBuf; } int getLastPos() { return _lastPos; } void setLastPos(int pos) { _lastPos = pos; } private: SOCKET _sockfd; char _szMsgBuf[RECV_BUFF_SIZE * 10]; //消息缓冲区数据尾部位置 int _lastPos; }; class EsayTcpServer { public: SOCKET _sock; //消息缓冲区 char _szRecv[RECV_BUFF_SIZE]; std::vector<ClientSocket*> _clients; CELLTimestamp _tTime; int _recvCount; public: EsayTcpServer() { _sock = INVALID_SOCKET; ZeroMemory(_szRecv, sizeof(_szRecv)); _recvCount = 0; } virtual ~EsayTcpServer() { Close(); } //初始化Socket SOCKET initSocket() { // 启动Windows socket 2.x环境 #ifdef _WIN32 WORD ver = MAKEWORD(2, 2); WSADATA dat; WSAStartup(ver, &dat); #endif //---------------- // 建立一个socket if (INVALID_SOCKET != _sock) { printf("<sock=%d>关闭之前的连接...\n", _sock); Close(); } _sock = socket(AF_INET, SOCK_STREAM, 0); if (INVALID_SOCKET == _sock) printf("错误,创建Socket失败...\n"); else printf("建立Socket成功...\n"); return _sock; } //绑定端口 int Bind(const char *ip, unsigned short port) { sockaddr_in sin = {}; sin.sin_family = AF_INET; sin.sin_port = htons(port); //host to net unsigned short #ifdef _WIN32 if (ip != NULL) { sin.sin_addr.S_un.S_addr = inet_addr(ip); } else { sin.sin_addr.S_un.S_addr = INADDR_ANY; //本机上的外网和局域网ip任意一个拿来用 } #else if (ip != NULL) { sin.sin_addr.s_addr = inet_addr(ip); //本机上的外网和局域网ip任意一个拿来用 } else { sin.sin_addr.s_addr = INADDR_ANY; //本机上的外网和局域网ip任意一个拿来用 } #endif //2绑定 if (SOCKET_ERROR == bind(_sock, (sockaddr *)&sin, sizeof(sockaddr_in))) { //TRACE(_T("ERROR:绑定socket失败\n")); return 0; } } //监听端口 int Listen(int n) { int ret = listen(_sock, n); if (SOCKET_ERROR == ret) { TRACE(_T("ERROR:socket监听失败")); } else { printf("监听开始\n"); } return ret; } //接受客户端连接 SOCKET Accept() { //4接收客户端连接 SOCKET cSock = INVALID_SOCKET; sockaddr_in clientAddr = {}; int nAddrLen = sizeof(sockaddr_in); cSock = accept(_sock, (sockaddr*)&clientAddr, &nAddrLen); if (INVALID_SOCKET == cSock) { printf("接收客户端无效\n"); } else { //广播所有客户端，新加入一个新的客户端 NewUserJoin newUser; SendDataToAll(&newUser); _clients.push_back(new ClientSocket(cSock)); printf("第<%d>个客户端加入socket = %d,ip:%s\n", _clients.size(), cSock, inet_ntoa(clientAddr.sin_addr)); } return cSock; } //关闭socket void Close() { if (_sock != INVALID_SOCKET) { #ifdef _WIN32 for (int n = _clients.size() - 1; n >= 0; n--) { closesocket(_clients[n]->sockfd()); if (_clients[n] != NULL) { delete _clients[n]; } } WSACleanup(); #else for (int n = _clients.size() - 1; n >= 0; n--) { close(_clients[n]->sockfd()); if (_clients[n] != NULL) { delete _clients[n]; } } #endif _clients.clear(); _sock = INVALID_SOCKET; } } int nCount = 0; //处理网络消息 bool OnRun() { fd_set fdRead; fd_set fdWrite; fd_set fdExp; FD_ZERO(&fdRead); FD_ZERO(&fdWrite); FD_ZERO(&fdExp); //将要监听的socket添加到数组 FD_SET(_sock, &fdRead); FD_SET(_sock, &fdWrite); FD_SET(_sock, &fdExp); SOCKET maxSock = _sock; //每次进来都把所有要监视的socket添加到相应的数组中 for (std::vector<ClientSocket*>::iterator it = _clients.begin(); it != _clients.end(); it++) { FD_SET((*it)->sockfd(), &fdRead); if (maxSock < (*it)->sockfd()) { maxSock = (*it)->sockfd(); } } //开始查询，会清空3个数组所有的socket，然后如果哪个socket有事件发送，则会把此socket放入到数组返回 //当有客户端连接或者客户端发送消息都会进来 timeval time = { 1, 0 }; /*int select( IN int nfds, //windows下无意义，linux有意义IN OUT fd_set* readfds, //检查可读性 IN OUT fd_set* writefds, //检查可写性 IN OUT fd_set* exceptfds, //例外数据 IN const struct timeval* timeout); //函数的返回时间*/ int ret = select(maxSock + 1, &fdRead, &fdWrite, &fdExp, &time); if (ret < 0) { printf("select任务结束\n"); Close(); return false; } if (FD_ISSET(_sock, &fdRead)) { FD_CLR(_sock, &fdRead); //4接收客户端连接 Accept(); } for (size_t n = 0; n < fdRead.fd_count; n++) { if (FD_ISSET(_clients[n]->sockfd(),&fdRead)) if (-1 == RecvData(_clients[n])) { auto iter = _clients.begin() + n; if (iter != _clients.end()) { delete _clients[n]; _clients.erase(iter); } } } } //是否在工作中 bool isRun() { return _sock != INVALID_SOCKET; } // 接受数据，处理粘包，拆分包 int RecvData(ClientSocket* pClient) { //接受客户端请求数据 int nLen = recv(pClient->sockfd(), _szRecv, RECV_BUFF_SIZE, 0); if (nLen <= 0) { printf("客户端<socket=%d>已退出，任务结束\n", pClient->sockfd()); return -1; } memcpy(pClient->msgBuf() + pClient->getLastPos(), _szRecv, nLen); pClient->setLastPos(pClient->getLastPos() + nLen); //判断消息缓冲区的数据长度大于消息头 while (pClient->getLastPos() >= sizeof(DataHeader)) { DataHeader* header = (DataHeader*)pClient->msgBuf(); //判断消息缓冲区的数据长度大于消息体 if (pClient->getLastPos() >= header->dataLength) { //剩余未处理消息缓冲区数据的长度 int nSize = pClient->getLastPos() - header->dataLength; OnNetMsg(pClient->sockfd(), header); //将未处理的数据前移 memcpy(pClient->msgBuf(), pClient->msgBuf() + header->dataLength, nSize); pClient->setLastPos(nSize); } else { //剩余数据小于一个消息体的大小 break; } } return 0; } // 响应网络消息 virtual void OnNetMsg(SOCKET cSock, DataHeader* header) { _recvCount++; auto t1 = _tTime.getElapsedSecond(); if (t1 >= 1.0) { printf("time = %lf 1秒收到数据包：%d\n", t1, _recvCount); _recvCount = 0; _tTime.update(); } switch (header->cmd) { case CMD_LOGIN: { Login* login = (Login*)header; //printf("收到命令 用户名：%s密码%s\n", login->userName, login->PassWord); LoginResult ret = {}; ret.result = 0; SendData(cSock, &ret); break; } case CMD_LOGOUT: { Logout* loginOut = (Logout*)header; //printf("收到命令： 数据长度：%d 用户名：%s密码%s\n", loginOut->dataLength, loginOut->userName); LogOutResult retOut = {}; retOut.result = 0; SendData(cSock, &retOut); break; } case CMD_ERROR: { printf("<socket = %d>收到服务端消息:CMD_ERROR,数据长度:%d\n", _sock, header->dataLength); break; } default: { printf("<socket = %d>收到未定义的消息,数据长度:%d\n", _sock, header->dataLength); break; } } } // 发送数据给指定的socket int SendData(SOCKET _cSock, DataHeader* header) { if (isRun() && header) send(_cSock, (const char*)header, header->dataLength, 0); return SOCKET_ERROR; } //群发 void SendDataToAll(DataHeader* header) { if (isRun() && header) { //广播所有客户端，新加入一个新的客户端 for (std::vector<ClientSocket*>::iterator it = _clients.begin(); it != _clients.end(); it++) { SendData((*it)->sockfd(), header); } } } private: }; #endif
MessageHeader.hpp：
#ifndef _MessageHeader_hpp_ #define _MessageHeader_hpp_ enum CMD { CMD_LOGIN, CMD_LOGIN_RESULT, CMD_LOGOUT, CMD_LOGOUT_RESULT, CMD_NEW_USER_JOIN, CMD_ERROR, }; // 消息头 struct DataHeader { DataHeader() { dataLength = sizeof(DataHeader); cmd = CMD_ERROR; } short dataLength; short cmd; }; struct Login :public DataHeader { Login() { dataLength = sizeof(Login); cmd = CMD_LOGIN; } char userName[32]; char PassWord[32]; char data[932]; }; struct LoginResult : public DataHeader { LoginResult() { dataLength = sizeof(LoginResult); cmd = CMD_LOGIN_RESULT; result = 0; } char data[992]; int result; }; struct Logout :public DataHeader { Logout() { dataLength = sizeof(Logout); cmd = CMD_LOGOUT; } char userName[32]; }; struct LogOutResult :public DataHeader { LogOutResult() { dataLength = sizeof(LogOutResult); cmd = CMD_LOGOUT_RESULT; result = 0; } int result; }; struct NewUserJoin :public DataHeader { NewUserJoin() { dataLength = sizeof(NewUserJoin); cmd = CMD_NEW_USER_JOIN; sock = 0; } int sock; }; #endif
CELLTimestamp.hpp：
#ifndef _CELL_TIMESTAMP_HPP_ #define _CELL_TIMESTAMP_HPP_ #include<chrono> using namespace std::chrono; class CELLTimestamp { public: CELLTimestamp() { update(); } ~CELLTimestamp() { } void update() { _begin = high_resolution_clock::now(); } //获取当前秒 double getElapsedSecond() { return getElapsedTimeInMicroSec()*0.000001; } //获取毫秒 double getElapsedTimeInMilliSec() { return getElapsedTimeInMicroSec()*0.001; } //获取微妙 long long getElapsedTimeInMicroSec() { return duration_cast<microseconds>(high_resolution_clock::now() - _begin).count(); } private: protected: time_point<high_resolution_clock> _begin; }; #endif
Client部分：一共3个文件（Client.cpp，EasyTcpClient.hpp和MessageHeader.hpp）
Client.cpp：
#define _CRT_SECURE_NO_WARNINGS #include <thread> #include "EasyTcpClient.hpp" #pragma comment(lib, "ws2_32.lib") #define CONNECT_COUNT 10 bool g_bRun = true; void cmdThread() { while (true) { char cmdBuf[256] = {}; scanf("%s", cmdBuf); if (0 == strcmp(cmdBuf, "exit")) { g_bRun = false; printf("退出cmdThread线程\n"); break; } else printf("不支持的命令。 \n"); } } int main() { const int cCount = 500; EasyTcpClient* client[cCount]; for (size_t i = 0; i < cCount; i++) { if (!g_bRun) { return 0; } client[i] = new EasyTcpClient(); } for (size_t i = 0; i < cCount; i++) { if (!g_bRun) { return 0; } client[i]->Connect("127.0.0.1", 10000); } std::thread t1(cmdThread); t1.detach(); // 线程分离 Login login; strcpy(login.userName, "lyd"); strcpy(login.PassWord, "lydmm"); while (g_bRun) { for (size_t i = 0; i < cCount; i++) { client[i]->OnRun(); client[i]->SendData(&login); } } for (size_t i = 0; i < cCount; i++) { client[i]->Close(); } printf("已退出。 \n"); getchar(); return 0; }
EasyTcpClient.hpp：
#pragma once #ifdef _WIN32 #include <WinSock2.h> #include <windows.h> #include "MessageHeader.hpp" #include <stdio.h> #else #include<unistd.h> #include<arpa/inet.h> #include<string.h> #define SOCKET int #define INVALID_SOCKET (SOCKET)(~0) #define SOCKET_ERROR (-1) #include <stdio.h> #endif #define RECV_BUFF_SIZE 10240 class EasyTcpClient { SOCKET _sock; //接受缓冲区 char _szRecv[RECV_BUFF_SIZE]; //第二缓冲区，消息缓冲区 char _szMsgBuf[RECV_BUFF_SIZE * 10]; //消息缓冲区的大小 int _lastPos = 0; public: EasyTcpClient() { _sock = INVALID_SOCKET; } virtual ~EasyTcpClient() { Close(); } // 初始化socket void initSocket() { // 启动Windows socket 2.x环境 #ifdef _WIN32 WORD ver = MAKEWORD(2, 2); WSADATA dat; WSAStartup(ver, &dat); #endif //---------------- // 建立一个socket if (INVALID_SOCKET != _sock) { printf("<sock=%d>关闭之前的连接...\n", _sock); Close(); } _sock = socket(AF_INET, SOCK_STREAM, 0); if (INVALID_SOCKET == _sock) printf("错误,创建Socket失败...\n"); else printf("建立Socket成功...\n"); } // 连接服务器 int Connect(const char* ip, unsigned short port) { if (INVALID_SOCKET == _sock) { initSocket(); } // 连接服务器 connect sockaddr_in _sin = {}; _sin.sin_family = AF_INET; _sin.sin_port = htons(port); #ifdef _WIN32 _sin.sin_addr.S_un.S_addr = inet_addr(ip); #else _sin.sin_addr.s_addr = inet_addr(ip); #endif int ret = connect(_sock, (sockaddr*)&_sin, sizeof(sockaddr_in)); if (SOCKET_ERROR == ret) printf("连接服务器错误...\n"); else printf("连接服务器成功...\n"); return ret; } void Close() { if (_sock != INVALID_SOCKET) { #ifdef _WIN32 closesocket(_sock); WSACleanup(); #else close(_sock); #endif _sock = INVALID_SOCKET; } } // 发送数据 // 接受数据 // 处理网络消息 bool OnRun() { if (isRun()) { fd_set fdReads; FD_ZERO(&fdReads); FD_SET(_sock, &fdReads); timeval t = { 0, 0 }; int ret = select(_sock + 1, &fdReads, 0, 0, &t); if (ret < 0) { printf("<socket=%d>select任务结束\n", _sock); return false; } if (FD_ISSET(_sock, &fdReads)) { FD_CLR(_sock, &fdReads); if (-1 == RecvData(_sock)) { printf("<socket=%d>select任务结束2\n", _sock); return false; } } return true; } return false; } bool isRun() { return _sock != INVALID_SOCKET; } // 接受数据，处理粘包，拆分包 int RecvData(SOCKET _cSock) { // 缓冲区 //ZeroMemory(_szRecv, sizeof(_szRecv)); int nLen = recv(_cSock, (char*)&_szRecv, RECV_BUFF_SIZE, 0); memcpy(_szMsgBuf + _lastPos, _szRecv, nLen); _lastPos += nLen; //判断消息缓冲区的数据长度大于消息头 while (_lastPos >= sizeof(DataHeader)) { DataHeader* header = (DataHeader*)_szMsgBuf; //判断消息缓冲区的数据长度大于消息体 if (_lastPos >= header->dataLength) { //剩余未处理消息缓冲区数据的长度 int nSize = _lastPos - header->dataLength; OnNetMsg(header); //将未处理的数据前移 memcpy(_szMsgBuf, _szMsgBuf + header->dataLength, nSize); _lastPos = nSize; } else { //剩余数据小于一个消息体的大小 break; } } return 0; } // 响应网络 void OnNetMsg(DataHeader* header) { switch (header->cmd) { case CMD_LOGIN_RESULT: { LoginResult* login = (LoginResult*)header; //printf("收到服务端消息:CMD_LOGIN_RESULT,数据长度:%d\n", header->dataLength); break; } case CMD_LOGOUT_RESULT: { LogOutResult* logout = (LogOutResult*)header; //printf("收到服务端消息:CMD_LOGOUT_RESULT,数据长度:%d\n", header->dataLength); break; } case CMD_NEW_USER_JOIN: { NewUserJoin* userJoin = (NewUserJoin*)header; //printf("收到服务端消息:CMD_NEW_USER_JOIN,数据长度:%d\n", header->dataLength); break; } case CMD_ERROR: { printf("<socket = %d>收到服务端消息:CMD_ERROR,数据长度:%d\n", _sock, header->dataLength); break; } default: { printf("<socket = %d>收到未定义的消息,数据长度:%d\n", _sock, header->dataLength); break; } } } // 发送数据 int SendData(DataHeader* header) { if (isRun() && header) send(_sock, (const char*)header, header->dataLength, 0); return SOCKET_ERROR; } };
MessageHeader.hpp：
#ifndef _MessageHeader_hpp_ #define _MessageHeader_hpp_ enum CMD { CMD_LOGIN, CMD_LOGIN_RESULT, CMD_LOGOUT, CMD_LOGOUT_RESULT, CMD_NEW_USER_JOIN, CMD_ERROR, }; // 消息头 struct DataHeader { DataHeader() { dataLength = sizeof(DataHeader); cmd = CMD_ERROR; } short dataLength; short cmd; }; struct Login :public DataHeader { Login() { dataLength = sizeof(Login); cmd = CMD_LOGIN; } char userName[32]; char PassWord[32]; char data[932]; }; struct LoginResult : public DataHeader { LoginResult() { dataLength = sizeof(LoginResult); cmd = CMD_LOGIN_RESULT; result = 0; } char data[992]; int result; }; struct Logout :public DataHeader { Logout() { dataLength = sizeof(Logout); cmd = CMD_LOGOUT; } char userName[32]; }; struct LogOutResult :public DataHeader { LogOutResult() { dataLength = sizeof(LogOutResult); cmd = CMD_LOGOUT_RESULT; result = 0; } int result; }; struct NewUserJoin :public DataHeader { NewUserJoin() { dataLength = sizeof(NewUserJoin); cmd = CMD_NEW_USER_JOIN; sock = 0; } int sock; }; #endif
111
