测试客户端

原创 已于 2024-12-26 09:11:52 修改 · 175 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#windows

于 2024-12-24 12:21:15 首次发布
#include <iostream>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <vector>
#include <map>
#include <string>
#include <ctime>
#include<algorithm>
using namespace std;
// 引入静态链接库
#pragma comment(lib, "ws2_32.lib")
#define HEARTBEATTIME  1000

class TcpServer {
public:
	TcpServer();
	~TcpServer();

	// 启动服务器，监听指定端口
	bool start(int port);

	// 停止服务器
	void stop();

	// 发送数据给指定客户端
	int sendData(SOCKET clientSocket, const char* data, int dataLength);

	// 处理服务器业务逻辑，通常在循环中调用
	void handle();

	// 链接
	static DWORD WINAPI ThreadAccept(LPVOID lpParam);
	// 接收数据
	static DWORD WINAPI ThreadRecvData(LPVOID lpParam);
	// 心跳包
	static DWORD WINAPI ThreadHeartBeat(LPVOID lpParam);
public:
	std::vector<SOCKET> socketsToRemove;
	BOOL  m_bExit;  // 程序是否关闭
	BOOL m_bHeartBeat;  // 是否启用心跳包
	int heartbeatInterval;  // 心跳包间隔时间（秒）
private:
	SOCKET listenSocket;
	std::vector<SOCKET> clientSockets;
	std::map<SOCKET, std::time_t> clientLastHeartbeatTime;



	// 设置套接字为非阻塞模式
	bool setSocketNonBlocking(SOCKET socket);

	// 接受新的客户端连接
	void acceptNewClients();

	// 接收客户端数据
	void receiveClientData();

	// 发送心跳包给客户端，并检测客户端响应
	void sendHeartbeatsAndCheck();

	// 移除已断开连接的客户端
	void removeDisconnectedClients(std::vector<SOCKET>& socketsToRemove);
};

// 构造函数，初始化相关成员变量
TcpServer::TcpServer() : listenSocket(INVALID_SOCKET),
	heartbeatInterval(5), m_bExit(false), m_bHeartBeat(false)
{
	WSADATA wsaData;
	WORD wVersionRequested = MAKEWORD(2, 2);
	int result = WSAStartup(wVersionRequested, &wsaData);
	if (result!= 0)
	{
		std::cerr << "WSAStartup failed: " << result << std::endl;
	}
}

// 析构函数，关闭套接字并清理WinSock环境
TcpServer::~TcpServer()
{
	stop();
	WSACleanup();
}

// 启动服务器，监听指定端口
bool TcpServer::start(int port)
{
	listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (listenSocket == INVALID_SOCKET)
	{
		std::cerr << "Socket creation failed: " << WSAGetLastError() << std::endl;
		return false;
	}

	if (!setSocketNonBlocking(listenSocket))
	{
		std::cerr << "Failed to set listen socket non-blocking" << std::endl;
		closesocket(listenSocket);
		return false;
	}

	sockaddr_in serverAddr;
	serverAddr.sin_family = AF_INET;
	serverAddr.sin_addr.s_addr = INADDR_ANY;
	serverAddr.sin_port = htons(port);
	int result = bind(listenSocket, (sockaddr*)&serverAddr, sizeof(serverAddr));
	if (result == SOCKET_ERROR)
	{
		std::cerr << "Bind failed: " << WSAGetLastError() << std::endl;
		closesocket(listenSocket);
		return false;
	}

	result = listen(listenSocket, SOMAXCONN);
	if (result == SOCKET_ERROR)
	{
		std::cerr << "Listen failed: " << WSAGetLastError() << std::endl;
		closesocket(listenSocket);
		return false;
	}

	return true;
}

// 停止服务器
void TcpServer::stop()
{
	if (listenSocket!= INVALID_SOCKET)
	{
		closesocket(listenSocket);
		listenSocket = INVALID_SOCKET;
	}
	for(int i=0;i<clientSockets.size();++i)
	{
		closesocket(clientSockets[i]);
	}
	clientSockets.clear();
	clientLastHeartbeatTime.clear();
}

// 设置套接字为非阻塞模式
bool TcpServer::setSocketNonBlocking(SOCKET socket)
{
	u_long iMode = 1;
	int result = ioctlsocket(socket, FIONBIO, &iMode);
	if (result == SOCKET_ERROR)
	{
		std::cerr << "ioctlsocket failed: " << WSAGetLastError() << std::endl;
		return false;
	}
	return true;
}

// 发送数据给指定客户端
int TcpServer::sendData(SOCKET clientSocket, const char* data, int dataLength)
{
	if (clientSocket == INVALID_SOCKET)
	{
		std::cerr << "Invalid client socket, cannot send data" << std::endl;
		return SOCKET_ERROR;
	}

	int totalBytesSent = 0;
	while (totalBytesSent < dataLength)
	{
		int bytesSent = ::send(clientSocket, data + totalBytesSent, dataLength - totalBytesSent, 0);
		if (bytesSent == SOCKET_ERROR)
		{
			if (WSAGetLastError() == WSAEWOULDBLOCK)
			{
				// 暂时无法发送，等待下次尝试
				continue;
			}
			return SOCKET_ERROR;
		}
		totalBytesSent += bytesSent;
	}
	return totalBytesSent;
}

// 接受新的客户端连接
void TcpServer::acceptNewClients()
{
	SOCKET newClientSocket = accept(listenSocket, NULL, NULL);
	if (newClientSocket == INVALID_SOCKET)
	{
		if (WSAGetLastError()!= WSAEWOULDBLOCK)
		{
			std::cerr << "Accept failed: " << WSAGetLastError() << std::endl;
		}
		return;
	}
	else
	{
		std::cout << "Accept success: " << newClientSocket << std::endl;
	}

	if (!setSocketNonBlocking(newClientSocket))
	{
		std::cerr << "Failed to set client socket non-blocking" << std::endl;
		closesocket(newClientSocket);
		return;
	}

	clientSockets.push_back(newClientSocket);
	clientLastHeartbeatTime[newClientSocket] = std::time(NULL);
}

// 接收客户端数据
void TcpServer::receiveClientData()
{
	for (size_t i = 0; i < clientSockets.size(); ++i)
	{
		SOCKET clientSocket = clientSockets[i];
		char buffer[1024];
		int bytesReceived = ::recv(clientSocket, buffer, sizeof(buffer), 0);
		if (bytesReceived == SOCKET_ERROR)
		{
			if (WSAGetLastError() == WSAEWOULDBLOCK)
			{
				// 暂时无数据可读，继续检查下一个客户端
				continue;
			}
		}
		else
		{
			buffer[bytesReceived] = '\0';
			std::string receivedData(buffer);
			// 在这里可以根据接收到的数据进行具体业务逻辑处理，比如解析命令等
			std::cout << "Received from client " << clientSocket << ": " << receivedData << std::endl;
			clientLastHeartbeatTime[clientSocket] = std::time(NULL);
			std::string heartbeatData = buffer;
			heartbeatData += "    recvok:";
			int sentBytes = sendData(clientSocket, heartbeatData.c_str(), heartbeatData.length());
		}
	}
}

// 发送心跳包给客户端，并检测客户端响应
void TcpServer::sendHeartbeatsAndCheck()
{
	const char* heartbeatData = "HEARTBEAT";  // 简单的心跳包内容，可自定义
	int dataLength = strlen(heartbeatData);
	for (std::map<SOCKET, std::time_t>::iterator it = clientLastHeartbeatTime.begin(); it!= clientLastHeartbeatTime.end(); ++it)
	{
		SOCKET clientSocket = it->first;
		std::time_t& lastHeartbeatTime = it->second;
		std::time_t currentTime = std::time(NULL);
		if (currentTime - lastHeartbeatTime > heartbeatInterval)
		{
			// 超过心跳间隔时间没收到心跳响应，认为客户端连接异常
			socketsToRemove.push_back(clientSocket);
			continue;
		}

		int sentBytes = sendData(clientSocket, heartbeatData, dataLength);
		if (sentBytes == SOCKET_ERROR)
		{
			// 发送心跳包失败，认为客户端连接可能有问题
			socketsToRemove.push_back(clientSocket);
			continue;
		}
	}
}

// 移除已断开连接的客户端（更新函数定义，无参数）
void TcpServer::removeDisconnectedClients(std::vector<SOCKET>& socketsToRemove)
{
	for (std::vector<SOCKET>::iterator it = socketsToRemove.begin(); it!= socketsToRemove.end(); ++it)
	{
		SOCKET socketToRemove = *it;
		vector<SOCKET>::iterator clientIt = find(clientSockets.begin(), clientSockets.end(), socketToRemove);
		if (clientIt!= clientSockets.end())
		{
			cout << "Remove :" << *clientIt << endl;
			clientSockets.erase(clientIt);
			clientLastHeartbeatTime.erase(socketToRemove);
		}
	}
}

// 接收链接线程
DWORD WINAPI TcpServer::ThreadAccept(LPVOID lpParam)
{
	TcpServer* t_Server = static_cast<TcpServer*>(lpParam);
	while (t_Server->m_bExit == false)
	{
		t_Server->acceptNewClients();
	}

	return 0;
}

// 接收数据
DWORD WINAPI TcpServer::ThreadRecvData(LPVOID lpParam)
{
	TcpServer* t_Server = static_cast<TcpServer*>(lpParam);
	while (t_Server->m_bExit == false)
	{
		t_Server->receiveClientData();
	}
	return 0;
}

// 心跳包
DWORD WINAPI TcpServer::ThreadHeartBeat(LPVOID lpParam)
{
	TcpServer* t_Server = static_cast<TcpServer*>(lpParam);
	while (t_Server->m_bExit == false)
	{
		Sleep(HEARTBEATTIME);
		t_Server->sendHeartbeatsAndCheck();

		if (t_Server->heartbeatInterval > 0)
		{
			t_Server->removeDisconnectedClients(t_Server->socketsToRemove);
		}
	}
	return 0;
}

// 处理服务器业务逻辑，通常在循环中调用
void TcpServer::handle()
{
	// 创建4个线程，分别进行接收链接  接收数据 发送数据 发送心跳包
	// 创建线程，传入当前对象指针作为参数，线程启动函数为 SendHeartbeat
	HANDLE acceptThreadHandle = CreateThread(NULL, 0, ThreadAccept, this, 0, NULL);
	if (acceptThreadHandle == NULL)
	{
		std::cerr << "Create accept thread failed: " << GetLastError() << std::endl;
	}
	else
	{
		std::cerr << "Create accept thread success: " << acceptThreadHandle << std::endl;
	}

	HANDLE recvDatatThreadHandle = CreateThread(NULL, 0, ThreadRecvData, this, 0, NULL);
	if (acceptThreadHandle == NULL)
	{
		std::cerr << "Create recvData thread failed: " << GetLastError() << std::endl;
	}
	else
	{
		std::cerr << "Create recvData thread success: " << recvDatatThreadHandle << std::endl;
	}

	if (m_bHeartBeat == true)
	{
		HANDLE heartBeatThreadHandle = CreateThread(NULL, 0, ThreadHeartBeat, this, 0, NULL);
		if (acceptThreadHandle == NULL)
		{
			std::cerr << "Create heartBeat thread failed: " << GetLastError() << std::endl;
		}
		else
		{
			std::cerr << "Create heartBeat thread success: " << heartBeatThreadHandle << std::endl;
		}
	}

}

int main()
{
	TcpServer server;
	server.heartbeatInterval = 30;
	server.m_bHeartBeat = true;
	if (server.start(6000))
	{
		while (true)
		{
			server.handle();
			// 可以在这里添加适当的延时，避免过于频繁地循环处理，消耗过多CPU资源
			Sleep(100);
			break;
		}
	}
	else
	{
		std::cout << "server initiatefail" << std::endl;
	}
	Sleep(1000000);
	return 0;
}


#include <iostream>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <string>
#include <process.h>  // 用于Windows下的线程相关操作
#include<list>
#include<vector>
using namespace std;
#pragma comment(lib, "ws2_32.lib")

#define SERVER_IP "127.0.0.1"
#define SERVER_PORT 6000
#define RECV_BUF_SIZE 1024
#define HEARTBEAT_INTERVAL 5000  // 心跳包发送间隔，单位：毫秒
#define HEARTBEAT_TIMEOUT 10000  // 心跳包超时时间，单位：毫秒
#define MAX_RECONNECT_ATTEMPTS 10 // 最大重连尝试次数
#define RECONNECT_INTERVAL_SECONDS 2  // 重连间隔时间（秒）

class TCPClient
{
public:
	TCPClient();
	~TCPClient();

	bool connectToServer();
	void disconnect();
	int sendData(const std::string& data);

private:
	SOCKET m_socket;
	sockaddr_in m_serverAddr;
	bool m_connected;

	// 心跳包相关变量和函数
	DWORD m_lastHeartbeatTime;
	bool m_heartbeatSent;
	HANDLE m_heartbeatThreadHandle;
	bool m_heartbeatThreadRunning;
	static unsigned int __stdcall HeartbeatThread(void* param);
	bool sendHeartbeat();
	bool checkHeartbeatResponse();

	// 用于设置套接字为非阻塞模式
	bool setSocketNonBlocking();
	// 尝试重连服务器
	bool reconnect();
	// 初始化Winsock库
	bool initializeWinsock();
	// 关闭套接字并清理相关资源
	void closeSocket();

	// 接收数据线程相关函数和变量
	static unsigned int __stdcall ReceiveDataThread(void* param);
	HANDLE m_receiveThreadHandle;
	bool m_receiveThreadRunning;
};

// 构造函数，初始化成员变量并初始化Winsock库
TCPClient::TCPClient() : m_socket(INVALID_SOCKET), m_connected(false),
	m_lastHeartbeatTime(0), m_heartbeatSent(false),
	m_heartbeatThreadHandle(NULL), m_heartbeatThreadRunning(false),
	m_receiveThreadHandle(NULL), m_receiveThreadRunning(false) 
{
		if (!initializeWinsock()) 
		{
			std::cerr << "初始化Winsock库失败" << std::endl;
		}

		m_serverAddr.sin_family = AF_INET;
		m_serverAddr.sin_port = htons(SERVER_PORT);
		if (inet_pton(AF_INET, SERVER_IP, &(m_serverAddr.sin_addr)) <= 0) 
		{
			std::cerr << "inet_pton转换IP地址错误" << std::endl;
		}
}

// 析构函数，断开连接并清理Winsock库，同时关闭心跳包线程和接收数据线程
TCPClient::~TCPClient()
{
	disconnect();
	if (m_heartbeatThreadHandle!= NULL) 
	{
		m_heartbeatThreadRunning = false;
		// 等待心跳包线程结束
		WaitForSingleObject(m_heartbeatThreadHandle, INFINITE);
		CloseHandle(m_heartbeatThreadHandle);
	}
	if (m_receiveThreadHandle!= NULL) 
	{
		m_receiveThreadRunning = false;
		// 等待接收数据线程结束
		WaitForSingleObject(m_receiveThreadHandle, INFINITE);
		CloseHandle(m_receiveThreadHandle);
	}
	WSACleanup();
}

// 连接服务器的函数
bool TCPClient::connectToServer()
{
	m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (m_socket == INVALID_SOCKET)
	{
		std::cerr << "创建套接字失败，错误码: " << WSAGetLastError() << std::endl;
		return false;
	}

	// 设置套接字为非阻塞模式
	if (!setSocketNonBlocking())
	{
		std::cerr << "设置套接字为非阻塞模式失败" << std::endl;
		closeSocket();
		return false;
	}

	int ret = connect(m_socket, (struct sockaddr*)&m_serverAddr, sizeof(m_serverAddr));
	if (ret == SOCKET_ERROR)
	{
		int errCode = WSAGetLastError();
		if (errCode!= WSAEWOULDBLOCK) 
		{
			std::cerr << "连接服务器失败，错误码: " << errCode << std::endl;
			closeSocket();
			return false;
		}
	}

	// 等待连接真正建立（非阻塞模式下需要轮询检查）
	timeval timeout;
	timeout.tv_sec = 5;  // 设置超时时间为5秒
	timeout.tv_usec = 0;
	fd_set writefds;
	FD_ZERO(&writefds);
	FD_SET(m_socket, &writefds);

	ret = select(0, NULL, &writefds, NULL, &timeout);
	if (ret == SOCKET_ERROR)
	{
		std::cerr << "select函数出错，错误码: " << WSAGetLastError() << std::endl;
		closeSocket();
		return false;
	} 
	else if (ret == 0)
	{
		std::cerr << "连接超时" << std::endl;
		closeSocket();
		return false;
	}

	if (FD_ISSET(m_socket, &writefds))
	{
		m_connected = true;
		// 创建并启动接收数据线程
		m_receiveThreadHandle = (HANDLE)_beginthreadex(NULL, 0, ReceiveDataThread, this, 0, NULL);
		if (m_receiveThreadHandle == NULL) 
		{
			std::cerr << "创建接收数据线程失败" << std::endl;
			closeSocket();
			return false;
		}
		m_receiveThreadRunning = true;

		// 创建并启动心跳包线程
		m_heartbeatThreadHandle = (HANDLE)_beginthreadex(NULL, 0, HeartbeatThread, this, 0, NULL);
		if (m_heartbeatThreadHandle == NULL) 
		{
			std::cerr << "创建心跳包线程失败" << std::endl;
			closeSocket();
			return false;
		}
		m_heartbeatThreadRunning = true;

		std::cout << "成功连接到服务器" << std::endl;
		return true;
	}

	return false;
}

// 断开与服务器连接的函数
void TCPClient::disconnect()
{
	if (m_connected) 
	{
		closesocket(m_socket);
		m_connected = false;
		std::cout << "已断开与服务器的连接" << std::endl;
	}
	m_receiveThreadRunning = false;
	m_heartbeatThreadRunning = false;
}

// 发送数据到服务器的函数
int TCPClient::sendData(const std::string& data) 
{
	if (!m_connected) 
	{
		if (reconnect())
		{

		}
		else
		{
			std::cerr << "未连接到服务器，无法发送数据" << std::endl;
			return SOCKET_ERROR;
		}
	}

	int ret = send(m_socket, data.c_str(), data.size(), 0);
	if (ret == SOCKET_ERROR) 
	{
		int errCode = WSAGetLastError();
		if (errCode == WSAEWOULDBLOCK) 
		{
			// 在非阻塞模式下，缓冲区满等情况会返回此错误，可根据需要处理
			return 0;
		} 
		else
		{
			std::cerr << "发送数据失败，错误码: " << errCode << std::endl;
			// 如果是连接断开相关错误，尝试重连
			if (errCode == WSAECONNRESET || errCode == WSAENETRESET)
			{
				if (reconnect())
				{
					// 重连成功后再次发送数据
					return sendData(data);
				}
			}
			return SOCKET_ERROR;
		}
	}
	return ret;
}

// 发送心跳包的函数
bool TCPClient::sendHeartbeat() 
{
	if (!m_connected)
	{
		return false;
	}

	const std::string heartbeatData = "HEARTBEAT_CLIENT";
	int ret = send(m_socket, heartbeatData.c_str(), heartbeatData.size(), 0);
	if (ret == SOCKET_ERROR)
	{
		int errCode = WSAGetLastError();
		if (errCode == WSAEWOULDBLOCK)
		{
			return false;
		}
		else 
		{
			std::cerr << "发送心跳包失败，错误码: " << errCode << std::endl;
			return false;
		}
	}
	m_heartbeatSent = true;
	return true;
}

// 检查心跳包响应的函数
bool TCPClient::checkHeartbeatResponse()
{
	if (!m_connected)
	{
		return false;
	}

	char buffer[RECV_BUF_SIZE];
	int ret = recv(m_socket, buffer, RECV_BUF_SIZE, 0);
	if (ret == SOCKET_ERROR)
	{
		int errCode = WSAGetLastError();
		if (errCode == WSAEWOULDBLOCK) 
		{
			return false;
		} 
		else
		{
			std::cerr << "接收心跳包响应失败，错误码: " << errCode << std::endl;
			return false;
		}
	}
	else if (ret == 0)
	{
		// 对方关闭了连接
		std::cerr << "服务器关闭了连接" << std::endl;
		disconnect();
		return false;
	} 
	else
	{
		std::string response(buffer, ret);
		if (response == "HEARTBEAT_ACK")
		{
			return true;
		}
	}
	return false;
}

// 设置套接字为非阻塞模式的函数
bool TCPClient::setSocketNonBlocking()
{
	u_long mode = 1;
	int ret = ioctlsocket(m_socket, FIONBIO, &mode);
	return ret!= SOCKET_ERROR;
}

// 尝试重连服务器的函数
bool TCPClient::reconnect()
{
	int attempt = 0;
	while (attempt < MAX_RECONNECT_ATTEMPTS)
	{
		attempt++;
		closeSocket();
		Sleep(RECONNECT_INTERVAL_SECONDS * 1000);  // 等待一段时间后重连

		m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
		if (m_socket == INVALID_SOCKET)
		{
			std::cerr << "重连时创建套接字失败，错误码: " << WSAGetLastError() << std::endl;
			continue;
		}

		// 设置套接字为非阻塞模式
		if (!setSocketNonBlocking())
		{
			std::cerr << "重连时设置套接字为非阻塞模式失败" << std::endl;
			closeSocket();
			continue;
		}

		int ret = connect(m_socket, (struct sockaddr*)&m_serverAddr, sizeof(m_serverAddr));
		if (ret == SOCKET_ERROR)
		{
			int errCode = WSAGetLastError();
			if (errCode!= WSAEWOULDBLOCK)
			{
				std::cerr << "重连失败，错误码: " << errCode << std::endl;
				continue;
			}
		}

		// 等待连接真正建立（非阻塞模式下需要轮询检查）
		timeval timeout;
		timeout.tv_sec = 5;  // 设置超时时间为5秒
		timeout.tv_usec = 0;
		fd_set writefds;
		FD_ZERO(&writefds);
		FD_SET(m_socket, &writefds);

		ret = select(0, NULL, &writefds, NULL, &timeout);
		if (ret == SOCKET_ERROR)
		{
			std::cerr << "重连时select函数出错，错误码: " << WSAGetLastError() << std::endl;
			closeSocket();
			continue;
		} 
		else if (ret == 0) 
		{
			std::cerr << "重连超时" << std::endl;
			closeSocket();
			continue;
		}

		if (FD_ISSET(m_socket, &writefds))
		{
			m_connected = true;
			// 重新创建并启动接收数据线程
			if (m_receiveThreadHandle!= NULL)
			{
				m_receiveThreadRunning = false;
				WaitForSingleObject(m_receiveThreadHandle, INFINITE);
				CloseHandle(m_receiveThreadHandle);
			}
			m_receiveThreadHandle = (HANDLE)_beginthreadex(NULL, 0, ReceiveDataThread, this, 0, NULL);
			if (m_receiveThreadHandle == NULL) 
			{
				std::cerr << "重连后创建接收数据线程失败" << std::endl;
				closeSocket();
				return false;
			}
			m_receiveThreadRunning = true;

			// 重新创建并启动心跳包线程
			if (m_heartbeatThreadHandle!= NULL) 
			{
				m_heartbeatThreadRunning = false;
				WaitForSingleObject(m_heartbeatThreadHandle, INFINITE);
				CloseHandle(m_heartbeatThreadHandle);
			}
			m_heartbeatThreadHandle = (HANDLE)_beginthreadex(NULL, 0, HeartbeatThread, this, 0, NULL);
			if (m_heartbeatThreadHandle == NULL) 
			{
				std::cerr << "重连后创建心跳包线程失败" << std::endl;
				closeSocket();
				return false;
			}
			m_heartbeatThreadRunning = true;

			std::cout << "重连成功" << std::endl;
			return true;
		}
	}
	std::cerr << "达到最大重连尝试次数，重连失败" << std::endl;
	return false;
}

// 初始化Winsock库的函数
bool TCPClient::initializeWinsock() 
{
	WSADATA wsaData;
	return WSAStartup(MAKEWORD(2, 2), &wsaData) == 0;
}

// 关闭套接字并清理相关资源的函数
void TCPClient::closeSocket() 
{
	if (m_socket!= INVALID_SOCKET) 
	{
		closesocket(m_socket);
		m_socket = INVALID_SOCKET;
	}
}

// 心跳包线程函数
unsigned int __stdcall TCPClient::HeartbeatThread(void* param)
{
	TCPClient* client = static_cast<TCPClient*>(param);
	while (client->m_heartbeatThreadRunning && client->m_connected) 
	{
		DWORD currentTime = GetTickCount();
		if (currentTime - client->m_lastHeartbeatTime >= HEARTBEAT_INTERVAL)
		{
			if (client->sendHeartbeat())
			{
				client->m_lastHeartbeatTime = currentTime;
			}
		}

		if (currentTime - client->m_lastHeartbeatTime > HEARTBEAT_TIMEOUT)
		{
			std::cerr << "心跳包超时，通知主线程尝试重连" << std::endl;
			client->m_connected = false;
			break;
		}

		Sleep(100);  // 适当休眠，避免过于频繁循环检查
	}
	return 0;
}

// 接收数据线程函数
unsigned int __stdcall TCPClient::ReceiveDataThread(void* param) 
{
	TCPClient* client = static_cast<TCPClient*>(param);
	std::string receivedData;
	while (client->m_receiveThreadRunning && client->m_connected) 
	{
		char recvBuf[RECV_BUF_SIZE];
		int ret = recv(client->m_socket, recvBuf, RECV_BUF_SIZE, 0);
		if (ret == SOCKET_ERROR)
		{
			int errCode = WSAGetLastError();
			if (errCode == WSAEWOULDBLOCK)
			{
				// 在非阻塞模式下，无数据可读时会返回此错误，可根据需要处理
				continue;
			}
			else 
			{
				std::cerr << "接收数据线程中接收数据失败，错误码: " << errCode << std::endl;
				// 如果是连接断开相关错误，通知主线程尝试重连
				if (errCode == WSAECONNRESET || errCode == WSAENETRESET) 
				{
					client->m_connected = false;
					break;
				}
			}
		} 
		else if (ret == 0)
		{
			// 对方关闭了连接
			std::cerr << "服务器关闭了连接（接收数据线程中）" << std::endl;
			client->m_connected = false;
			break;
		} 
		else
		{
			receivedData.assign(recvBuf, ret);
			std::cout << "接收数据线程从服务器接收到数据: " << receivedData << std::endl;
		}
	}
	return 0;
}

int main() 
{
	TCPClient client;

	if (client.connectToServer())
	{
		while (true)
		{
			// 发送数据示例
			std::string sendDataStr = "Hello, server!\n";
			client.sendData(sendDataStr);

			// 简单的休眠，避免过于频繁循环
			Sleep(100);
		}
	}
	return 0;
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值