非阻塞模式多线程《客户端与服务器算数运算》 TCP/IP通信之一客户端实现

谁践踏了优雅 2022-05-23 09:48 141阅读 0赞

1.  代码来源于 》》》》》》》》》》》》》》》》》》》》》 Windows Sockets网络开发VC++ 这本书

1.  在stdafx.h 中添加 \#pragma comment(lib,"ws2\_32.lib")

//funtiondec.h
    
    #include "winsock2.h" 
    
    #define CLIENT_SETUP_FAIL 1 //启动客户端失败
    #define CLIENT_CREATETHREAD_FAIL 2 //创建线程失败
    #define TIMEFOR_THREAD_EXIT 5000 //主线程睡眠时间
    #define TIMEFOR_THREAD_SLEEP 500 //等待客户端请求线程睡眠时间
    #define TIMEFOR_THREAD_CLIENT 500 //线程睡眠
    #define TIMEFOR_THREAD_HELP  500 
    #define SERVERPORT 5556  //服务器TCP端口
    #define MAX_NUM_BUF 48  //缓冲区的最大长度
    
    //数据包类型和包头长度
    #define EXPRESSION 'E' //算数表达式
    #define BYEBYE 'B'  //消息byebye
    #define HEADERLEN (sizeof(hdr)) //头长度
    
    void InitMember(void);
    BOOL ConnectServer(void);
    BOOL CreateSendAndRecvThread(void);
    void InputAndOutPut(void);
    BOOL PackExpression(const char *pExpr);
    BOOL PackByebye(const char *pExpr);
    void ExitClient(void);
    DWORD __stdcall SendDataThread(void* pParam);
    DWORD __stdcall RecvDataThread(void* pParam);
    void ShowDataRecultMsg();
    
    //数据包头结构，该结构在win32下为4byte
    typedef struct _head
    {
    	char type;  //类型
    	unsigned short len;  //数据包的长度（包括头的长度）
    }hdr, *phdr;
    
    //数据包中的数据结构
    typedef struct _data
    {
    	char buf[MAX_NUM_BUF];  //数据
    
    }DATABUF, *pDataBuf;

// ClientCounting.cpp : 定义控制台应用程序的入口点。
    // 在BOOL ConnectServer(void) 函数中  记得重新设置   本机IP地址
    
    
    #include "stdafx.h"
    #include "winsock2.h" 
    #include "funtiondec.h"   //所需函数声明  
    #include <iostream>
    
    using namespace std;
    
    SOCKET sClient;  //套接字
    HANDLE hThreadSend;  //发送数据线程
    HANDLE hThreadRecv;  //接收数据线程
    DATABUF bufSend;  //发送数据缓冲区
    DATABUF bufRecv;  //接收数据缓冲区
    CRITICAL_SECTION csSend;  //临界区对象 锁定bufSend
    CRITICAL_SECTION csRecv;  //临界区对象 锁定bufRecv
    BOOL bSendData;  //通知发送数据线程
    HANDLE hEventShowDataResult;  //显示计算结果的事件
    BOOL bConnecting;  //与服务器的连接状态
    HANDLE arrThread[2];  //子线程数组
    
    /*
    	初始化全局变量
    */
    void InitMember(void)
    {
    	//初始化临界区
    	InitializeCriticalSection(&csSend);
    	InitializeCriticalSection(&csRecv);
    
    	sClient = INVALID_SOCKET;  //套接字
    	hThreadRecv = NULL;  //接收数据线程句柄
    	hThreadSend = NULL;  //发送数据线程句柄
    	bConnecting = FALSE;  //为连接状态
    	bSendData = FALSE;  //不发送数据状态
    
    	//初始化数据缓冲区
    	memset(bufSend.buf, 0, MAX_NUM_BUF);
    	memset(bufRecv.buf, 0, MAX_NUM_BUF);
    	memset(arrThread, 0, 2);
    
    	//手动设置事件，初始化为无信号状态
    	hEventShowDataResult = (HANDLE)CreateEvent(NULL, TRUE, FALSE, NULL);
    
    }
    
    /*
    	创建非阻塞套接字
    */
    BOOL InitSocket(void)
    {
    	int reVal;  //返回值
    	WSADATA  wsData;  //
    	reVal = WSAStartup(MAKEWORD(2, 2), &wsData);  //初始化Windows Sockets
    
    	//创建套接字
    	sClient = socket(AF_INET, SOCK_STREAM, 0);
    	if (INVALID_SOCKET == sClient)
    	{
    		return FALSE;
    	}
    
    	//设置套接字非阻塞模式
    	unsigned long ul = 1;
    	reVal = ioctlsocket(sClient, FIONBIO, (unsigned long*)&ul);
    	if (reVal == SOCKET_ERROR)
    		return FALSE;
    
    	return TRUE;
    
    }
    
    /*
    	连接服务器
    */
    BOOL ConnectServer(void)
    {
    	int reVal;  //返回值
    	sockaddr_in serAddr;  //服务器地址
    
    	serAddr.sin_family = AF_INET;
    	serAddr.sin_port = htons(SERVERPORT);
    	serAddr.sin_addr.S_un.S_addr = inet_addr("192.168.78.1");  //本机IP地址
    	for (;;)
    	{
    		//连接服务器
    		reVal = connect(sClient, (struct sockaddr*)&serAddr, sizeof(serAddr));
    
    		//处理连接错误
    		if (SOCKET_ERROR == reVal)
    		{
    			int nErrCode = WSAGetLastError();
    			if (WSAEWOULDBLOCK == nErrCode  //连接还没有完成
    				|| WSAEINVAL == nErrCode)
    			{
    				continue;
    			}
    			else if (WSAEISCONN == nErrCode)  //连接已经完成
    			{
    				break;
    			}
    			else
    			{
    				return FALSE;  //其他原因，连接失败
    			}
    		}
    		if (reVal == 0)  //连接成功
    			break;
    	}
    
    	bConnecting = TRUE;
    	 
    	return TRUE;
    }
    
    /*
    	创建发送和接收数据线程
    */
    BOOL CreateSendAndRecvThread(void)
    {
    	//创建接收数据的线程
    
    	unsigned long ulThreadId;
    	hThreadRecv = CreateThread(NULL, 0, RecvDataThread, NULL, 0, &ulThreadId);
    	if (NULL == hThreadRecv)
    		return FALSE;
    
    	//创建发送数据的线程
    	hThreadSend = CreateThread(NULL, 0, SendDataThread, NULL,0, &ulThreadId);
    	if (NULL == hThreadSend)
    		return FALSE;
    
    	//添加到线程数组
    	arrThread[0] = hThreadRecv;
    	arrThread[1] = hThreadSend;
    
    	return TRUE;
    }
    
    /*
    	输入数据和显示结果
    */
    void InputAndOutPut(void)
    {
    	char cInput[MAX_NUM_BUF];  //用户输入缓冲区
    	BOOL bFirstInput = TRUE;  //第一次只能输入算数表达式
    
    	for (; bConnecting;)  //连接状态
    	{
    		memset(cInput, 0, MAX_NUM_BUF);
    
    		//提示输入表达式
    		printf_s("输入表达式,形如:a+b=\n");
    		printf_s("若想退出客户端输入:byebye 或 Byebye\n");
    		printf_s("第一次不能输入byebye\n");
    		cin >> cInput;
    		
    		char *pTemp = cInput;
    		if (bFirstInput)
    		{
    			if (!PackExpression(pTemp))  //算数表达式打包
    			{
    				continue;   //重新输入
    			}
    			bFirstInput = FALSE;  //成功输入第一个算数表达式
    		}
    		else if (!PackByebye(pTemp))  //:"Byebye" "byebye" 打包
    		{
    			if (!PackExpression(pTemp))  //算数表达式打包
    			{
    				continue;  //重新输入
    			}
    		}
    		
    		//等待显示计算结果
    		if (WAIT_OBJECT_0 == WaitForSingleObject(hEventShowDataResult, INFINITE))
    		{
    			ResetEvent(hEventShowDataResult);  //设置为无信号状态
    			if (!bConnecting)  //客户端被动退出，此时接收和发送数据线程已经退出
    			{
    				break;
    			}
    
    			ShowDataRecultMsg();  //显示数据结果
    
    			if (0 == strcmp(bufRecv.buf, "OK"))  //客户端主动退出
    			{
    				bConnecting = FALSE; 
    				Sleep(TIMEFOR_THREAD_EXIT);  //给数据接收和发送线程退出时间
    			}
    		}
    
    	}
    
    	if (!bConnecting)  //与服务器连接已经断开
    	{
    		printf_s("与服务器连接已经断开\n");  //显示信息
    	}
    
    	//等待数据发送和接收线程退出
    	DWORD reVal = WaitForMultipleObjects(2, arrThread, TRUE, INFINITE);
    	if (WAIT_ABANDONED_0 == reVal)
    	{
    		int nErrCode = GetLastError();
    	}
    
    }
    
    /*
    	判断byebye
    */
    BOOL PackByebye(const char *pExpr)
    {
    	if (strcmp(pExpr, "Byebye") == 0|| strcmp(pExpr, "byebye") == 0)
    	{
    		//表达式读入发送数据缓冲区
    		EnterCriticalSection(&csSend);  //进入临界区
    		//数据包头
    		phdr pHeader = (phdr)(bufSend.buf);
    		pHeader->type = BYEBYE;
    		pHeader->len = 7 + HEADERLEN;
    
    		//拷贝数据
    		memcpy(bufSend.buf + HEADERLEN, pExpr, 7);
    		LeaveCriticalSection(&csSend);  //离开临界区
    		pHeader = NULL;
    
    		bSendData = TRUE;  //通知发送数据线程发送数据
    		return TRUE;
    	}
    	else
    	{
    		return FALSE;
    	}
    
    
    }
    
    /*
    	打包计算表达式的数据
    */
    BOOL PackExpression(const char *pExpr)
    {
    	char *pTemp = (char*)pExpr;  //算数表达式数字开始的位置
    	while (!*pTemp)  //第一个数字位置
    		pTemp++;
    
    	char* pos1 = pTemp; //第一个数字位置
    	char* pos2 = NULL;  //运算符位置
    	char* pos3 = NULL;  //第二个数字位置
    	int len1 = 0;  //第一个数字长度
    	int len2 = 0;  //运算符长度
    	int len3 = 0;  //第二个数字长度
    
    	//第一个字符是+ - 或者是数字
    	if ((*pTemp != '+')
    		&& (*pTemp != '-')
    		&& ((*pTemp < '0') || (*pTemp > '9')))
    	{
    		return FALSE;
    	}
    
    	//第一个字符是'+' 第二个是数字
    	if ((*pTemp++ == '+') && (*pTemp < '0' || *pTemp > '9'))
    		return FALSE;
    	--pTemp;
    
    	//第一个字符是'-' 第二个是数字
    	if ((*pTemp++ == '-') && (*pTemp < '0' || *pTemp > '9'))
    		return FALSE;
    	--pTemp;
    
    	char* pNum = pTemp;  //数字开始的位置
    	if (*pTemp == '+' || *pTemp == '-')
    		pTemp++;
    
    	while (*pTemp >= '0' && *pTemp <= '9')
    		pTemp++;
    
    	len1 = pTemp - pNum; 
    
    	//可能有空格
    	while (!*pTemp)
    		pTemp++;
    
    	//算数运算符
    	if (('+' != *pTemp)
    		&& ('-' != *pTemp)
    		&& ('*' != *pTemp)
    		&& ('/' != *pTemp))
    		return FALSE;
    
    	pos2 = pTemp;
    	len2 = 1;
    
    	//下移指针
    	pTemp++;
    	//可能有空格
    	while (!*pTemp)
    		pTemp++;
    
    	//第2个数字位置
    	pos3 = pTemp;
    	if (*pTemp < '0' || *pTemp > '9')
    		return FALSE; 
    
    	while (*pTemp >= '0' && *pTemp <= '9')
    		pTemp++;
    
    	if ('=' != *pTemp)
    		return FALSE;
    
    	len3 = pTemp - pos3;  //数字长度
    
    	int nExprlen = len1 + len2 + len3;
    
    	//表达式读入发送数据缓冲区
    	EnterCriticalSection(&csSend);  //进入临界区
    	//数据包头
    	phdr pHeader = (phdr)(bufSend.buf); 
    	pHeader->type = EXPRESSION;
    	pHeader->len = nExprlen + HEADERLEN;
    
    	//拷贝数据
    	memcpy(bufSend.buf + HEADERLEN, pos1, len1);
    	memcpy(bufSend.buf + HEADERLEN + len1, pos2, len2);
    	memcpy(bufSend.buf + HEADERLEN + len1 + len2, pos3, len3);
    	LeaveCriticalSection(&csSend);  //离开临界区
    	pHeader = NULL;
    
    	bSendData = TRUE;  //通知发送数据线程发送数据
    	return TRUE; 
    
    }
    
    /*
    释放资源
    */
    void ExitClient(void)
    {
    	DeleteCriticalSection(&csSend);  //释放临界区对象
    	DeleteCriticalSection(&csRecv);  //释放临界区对象
    	closesocket(sClient); //关闭SOCKET
    	WSACleanup(); //卸载Windowss Sockets DLL
    }
    
    /*
    	发送数据线程
    */
    DWORD __stdcall SendDataThread(void* pParam)
    {
    	while (bConnecting)
    	{
    		if (bSendData)
    		{
    			EnterCriticalSection(&csSend);  //进入临界区
    			for (;;)
    			{
    				int nBuflen = ((phdr)(bufSend.buf))->len;
    				int val = send(sClient, bufSend.buf, nBuflen, 0);
    
    				//处理返回错误
    				if (SOCKET_ERROR == val)
    				{
    					int nErrCode = WSAGetLastError();
    					if (WSAEWOULDBLOCK == nErrCode) //发送缓冲区不可用
    					{
    						continue;  //继续循环
    					}
    					else
    					{
    						LeaveCriticalSection(&csSend);  //离开临界区
    						bConnecting = FALSE;  //断开状态
    						SetEvent(hEventShowDataResult);  //通知主线程，防止在无限期的等待
    
    						return 0;
    					}
    
    				}
    				bSendData = FALSE; //发送状态
    				break;  //跳出for
    			}
    			LeaveCriticalSection(&csSend);  //离开临界区
    		}
    		Sleep(TIMEFOR_THREAD_SLEEP);  //线程睡眠
    	}
    	return 0;
    }
    
    /*
    	接收数据线程
    */
    DWORD __stdcall RecvDataThread(void* pParam)
    {
    	int reVal;  //返回值
    	char temp[MAX_NUM_BUF];  
    	memset(temp, 0, MAX_NUM_BUF);
    
    	while (bConnecting)
    	{
    		reVal = recv(sClient, temp, MAX_NUM_BUF, 0); //接收数据
    		
    		if (SOCKET_ERROR == reVal)
    		{
    			int nErrCode = WSAGetLastError();
    			if (WSAEWOULDBLOCK == nErrCode)  //接受数据缓冲区不可用
    			{
    				Sleep(TIMEFOR_THREAD_SLEEP);  //线程睡眠
    				continue;
    			}
    			else
    			{
    				bConnecting = FALSE;
    				SetEvent(hEventShowDataResult); //通知住线程，防止在无限期的等待
    				return 0;
    			}
    		}
    
    		if (reVal == 0)  //服务器关闭了连接
    		{
    			bConnecting = FALSE;
    			SetEvent(hEventShowDataResult); //通知主线程，放置在无限期的等待
    			return 0; 
    
    		}
    		if (reVal > HEADERLEN && -1 != reVal)  //收到数据
    		{
    			// 对数据解包，将数据结果赋值到接收数据缓冲区
    			phdr header = (phdr)(temp);
    			EnterCriticalSection(&csRecv);
    			memset(bufRecv.buf, 0, MAX_NUM_BUF);
    			memcpy(bufRecv.buf, temp + HEADERLEN, header->len - HEADERLEN);
    			LeaveCriticalSection(&csRecv);
    			
    			SetEvent(hEventShowDataResult);  //通知主线程显示计算结果
    			memset(temp, 0, MAX_NUM_BUF);
    		}
    		Sleep(TIMEFOR_THREAD_SLEEP);  //线程睡眠
    	}
    
    	return 0;
    }
    
    void ShowDataRecultMsg()
    {
    	printf("ClientRecvLine:%s\n", bufRecv.buf);
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	
    	//初始化全局变量
    	InitMember();
    	
    	//初始化客户端
    	if (!InitSocket())
    	{
    		printf("初始化失败\n");
    		ExitClient();
    		return CLIENT_SETUP_FAIL;
    	}
    	else
    	{
    		printf("初始化成功\n");
    	}
    	
    	//连接服务器
    
    	if (ConnectServer())
    	{
    		printf("连接服务器成功!\n");
    	}
    	else
    	{
    		printf("连接服务器失败!\n");
    		ExitClient();
    		return CLIENT_SETUP_FAIL;
    	}
    	
    	//创建发送和接收数据线程
    	if (!CreateSendAndRecvThread())
    	{
    		ExitClient();
    		return CLIENT_CREATETHREAD_FAIL;
    	}
    
    	//用户输入数据和显示结果
    	InputAndOutPut();
    
    	//退出
    	ExitClient();
    
    	return 0;
    }