4---为客户端添加输入线程

一、为客户端添加输入线程
在前一篇文章中我们的客户端不能手动的在命令行中输入命令发送给服务端，而是简单地书写了一小段代码，然后发送给服务端
此处我们为客户端添加一个线程，此处采用的是C++11中的线程对象std::thread
二、代码设计思路
设计了一个全局变量g_bRun代表当前客户端正在运行，main函数主循环while中使用g_bRun
在主循环while之前设计创建一个C++11线程对象，线程运行函数名为cmdThread()，函数参数为客户端的socket。并且该线程分离出了主线程（为什么要分离，下面介绍）
在cmdThread()函数中输入数据并且发送给服务端之后，select检测到客户端的socket变为可读，于是打印服务端发送过来的数据
cmdThread()函数运行时，如果输入exit，代表客户端退出，那么将全局变量g_bRun设置为false，那么主循环while终止，客户端socket关闭，程序终止
三、代码如下

#define WIN32_LEAN_AND_MEAN
#define _WINSOCK_DEPRECATED_NO_WARNINGS //for inet_pton()
#define _CRT_SECURE_NO_WARNINGS
 
#include <windows.h>
#include <WinSock2.h>
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <thread>
 
#pragma comment(lib, "ws2_32.lib")
 
using namespace std;
 
enum CMD
{
	CMD_LOGIN,       
	CMD_LOGIN_RESULT, 
	CMD_LOGOUT,      
	CMD_LOGOUT_RESULT,
	CMD_NEW_USER_JOIN,
	CMD_ERROR   
};
 
struct DataHeader
{
	short cmd;       
	short dataLength;
};
 
struct Login :public DataHeader
{
	Login() {
		cmd = CMD_LOGIN;
		dataLength = sizeof(Login);
	}
	char userName[32]; 
	char PassWord[32]; 
};
 
struct LoginResult :public DataHeader
{
	LoginResult() :result(0) {
		cmd = CMD_LOGIN_RESULT;
		dataLength = sizeof(LoginResult);
	}
	int result;
};
 
struct Logout :public DataHeader
{
	Logout() {
		cmd = CMD_LOGOUT;
		dataLength = sizeof(Logout);
	}
	char userName[32];
};
 
struct LogoutResult :public DataHeader
{
	LogoutResult():result(0){
		cmd = CMD_LOGOUT_RESULT;
		dataLength = sizeof(LogoutResult);
	}
	int result;
};
 
struct NewUserJoin :public DataHeader
{
	NewUserJoin(int _cSocket = 0) :sock(_cSocket) {
		cmd = CMD_NEW_USER_JOIN;
		dataLength = sizeof(LogoutResult);
	}
	int sock;
};
 
int processor(SOCKET _cSock);
 
void cmdThread(SOCKET sock);
 
bool g_bRun = true; //表示客户端已经结束，让主循环while为false，关闭客户端套接字
 
int main()
{
	WORD ver = MAKEWORD(2, 2);
	WSADATA dat;
	WSAStartup(ver, &dat);
 
	//建立socket
	SOCKET _sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (INVALID_SOCKET == _sock) {
		std::cout << "ERROR:建立socket失败!" << std::endl;
	}
	else {
		std::cout << "建立socket成功!" << std::endl;
	}
 
	//声明要连接的服务端地址
	struct sockaddr_in _sin = {};
	_sin.sin_addr.S_un.S_addr = inet_addr("192.168.0.104");
	_sin.sin_family = AF_INET;
	_sin.sin_port = htons(4567);
 
	//连接服务端
	int ret = connect(_sock, (struct sockaddr*)&_sin, sizeof(_sin));
	if (SOCKET_ERROR == ret) {
		std::cout << "ERROR:连接服务端失败!" << std::endl;
	}
	else {
		std::cout << "连接服务端成功!" << std::endl;
	}
 
	//启动线程，线程执行函数的参数传入_sock
	std::thread t1(cmdThread, _sock);
	t1.detach();//分离线程
	/*为什么要分离线程：
		在cmdThread()中如果我们输入exit，那么会将全局变量g_bRun设置为false，
		设置为false之后，下面的while主循环就会终止，从而导致主线程结束，但是此时我们的t1线程可能还没有
		完全退出，因此需要将t1线程分理出主线程，否则客户端在输入exit的时候可能会抛出异常
	*/
 
	while (g_bRun)
	{
		fd_set fdRead;
		FD_ZERO(&fdRead);
		FD_SET(_sock, &fdRead);
 
		struct timeval t = { 1,0 };
		int ret = select(_sock + 1, &fdRead, NULL, NULL, &t);
		if (ret < 0)
		{
			std::cout << "select出错！" << std::endl;
			break;
		}
		if (FD_ISSET(_sock, &fdRead)) //如果服务端有数据发送过来，接收显示数据
		{
			FD_CLR(_sock, &fdRead);
			if (-1 == processor(_sock))
			{
				std::cout << "数据接收失败，或服务端已断开！" << std::endl;
				break;
			}
		}
		//Sleep(1000); 可以让发送与接受速度延迟1秒
		//std::cout << "空闲时间，处理其他业务..." << std::endl;
	}
 
	//关闭服务端套接字
	closesocket(_sock);
	WSACleanup();
 
	std::cout << "客户端停止工作!" << std::endl;
	getchar();  //防止程序一闪而过
	return 0;
}
 
int processor(SOCKET _cSock)
{
	//设置接收缓冲区，并接收命令
	char szRecv[1024];
	int _nLen = recv(_cSock, szRecv, sizeof(DataHeader), 0);
	if (_nLen < 0) {
		std::cout << "recv函数出错！" << std::endl;
		return -1;
	}
	else if (_nLen == 0) {
		std::cout << "服务端已关闭!" << std::endl;
		return -1;
	}
 
	//在此处还应该判断少包黏包的问题，但是现在处于单机处理状态，后面介绍到复杂的消息通信时再介绍
 
	//获取消息中头部中的信息
	DataHeader* header = (DataHeader*)szRecv;
	switch (header->cmd)
	{
		case CMD_LOGIN_RESULT:   //如果返回的是登录的结果
		{
			recv(_cSock, (char*)szRecv + sizeof(DataHeader), header->dataLength + sizeof(DataHeader), 0);
			LoginResult* loginResult = (LoginResult*)szRecv;
			std::cout << "收到服务端数据：CMD_LOGIN_RESULT,数据长度：" << loginResult->dataLength << "，结果为：" << loginResult->result << std::endl;
		}
		break;
		case CMD_LOGOUT_RESULT:  //如果是退出的结果
		{
			recv(_cSock, (char*)szRecv + sizeof(DataHeader), header->dataLength + sizeof(DataHeader), 0);
			LogoutResult* logoutResult = (LogoutResult*)szRecv;
			std::cout << "收到服务端数据：CMD_LOGOUT_RESULT,数据长度：" << logoutResult->dataLength << "，结果为：" << logoutResult->result << std::endl;
		}
		break;
		case CMD_NEW_USER_JOIN:  //有新用户加入
		{
			recv(_cSock, (char*)szRecv + sizeof(DataHeader), header->dataLength + sizeof(DataHeader), 0);
			NewUserJoin* newUserJoin = (NewUserJoin*)szRecv;
			std::cout << "收到服务端数据：CMD_NEW_USER_JOIN,数据长度：" << newUserJoin->dataLength << "，新用户Socket为：" << newUserJoin->sock << std::endl;
		}
		break;
	}
 
	return 0;
}
 
void cmdThread(SOCKET sock)
{
	char cmdBuf[256] = {};
	while (true)
	{
		std::cin >> cmdBuf;
 
		if (0 == strcmp(cmdBuf, "exit"))
		{
			std::cout << "客户端退出" << std::endl;
			g_bRun = false; //设置客户端已经停止运行
			break;
		}
		else if (0 == strcmp(cmdBuf, "login"))
		{
			Login login;
			strcpy(login.userName, "dongshao");
			strcpy(login.PassWord, "123456");
			send(sock, (const char*)&login, sizeof(login), 0);
		}
		else if (0 == strcmp(cmdBuf, "logout"))
		{
			Logout logout;
			strcpy(logout.userName, "dongshao");
			send(sock, (const char*)&logout, sizeof(logout), 0);
		}
		else {
			std::cout << "命令不识别，请重新输入" << std::endl;
		}
	}
}

五、输入线程为什么要分离
在cmdThread()中如果我们输入exit，那么会将全局变量g_bRun设置为false，设置为false之后，下面的while主循环就会终止，从而导致主线程结束，但是此时我们的t1线程可能还没有完全退出，因此需要将t1线程分理出主线程，否则客户端在输入exit的时候可能会抛出异常
例如：下面是将客户端代码中的“t1.detach();”注释掉之后，然后再输入exit退出客户端的结果，程序抛出异常