• 多线程+socket 实现群聊服务器

    通过多线程+Socket，实现群聊服务器。

    服务端：

    • 每当有一个连接时，服务端起一个线程去维护；
    • .将收到的信息转发给所有的客户端；
    • 当某个客户端断开连接时需要处理断开连接

    客户端：

    • 接收与发送信息
    • 断开连接
    • 自定义用户名

    最终效果：（这里演示的是三个客户端之间的聊天效果，按照从左至右、从上至下的顺序发送消息）

    目录

    服务端  

    客户端

    通过命令行运行程序

    服务端  

    首先准备一个TCP的模板：

    TCP套接字编程详解

    1. #include 
    2. #include//第二版本的网络库
    3. #pragma comment(lib,"ws2_32.lib")
    4.  
    5. int main() {
    6. 	//初始化套接字库
    7. 	WORD wVersion;
    8. 	WSADATA wsaData;
    9. 	int err;
    10.  
    11. 	wVersion = MAKEWORD(1, 1);  //MAKEWORD(a,b) b|a<<8
    12. 	err = WSAStartup(wVersion, &wsaData);
    13. 	//检查1
    14. 	if (err != 0) {
    15. 		return err;
    16. 	}
    17. 	//检查2
    18. 	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
    19. 		//清理套接字库
    20. 		WSACleanup();
    21. 		return -1;
    22. 	}
    23. 	//创建tcp套接字
    24. 	SOCKET sockSrv = socket(AF_INET, SOCK_STREAM, 0);
    25. 	//绑定到本机
    26. 	//绑定即要指明绑定的哪个IP地址，同时指明绑定的端口号
    27. 	//准备绑定信息
    28. 	SOCKADDR_IN addrSrv;
    29. 	addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
    30. 	//协议族，与上面保持一致
    31. 	addrSrv.sin_family = AF_INET;
    32. 	//端口；0~65535，其中1024以下的端口为系统保留的
    33. 	addrSrv.sin_port = htons(6000);
    34. 	//绑定
    35. 	if (bind(sockSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR)) == SOCKET_ERROR) {
    36.  
    37. 		printf("bind ERROR ERRORnum=%d\n", GetLastError());
    38. 	}
    39.  
    40. 	//监听
    41. 	//linsten用来监听该端口上的连接数，当执
    42. 	if (listen(sockSrv, 10) == SOCKET_ERROR) {
    43. 		printf("linten ERROR ROOROnum=%d\n", GetLastError());
    44. 	}
    45. 	std::cout << "Server start at 6000" << std::endl;
    46.  
    47. 	//接收请求前的准备工作
    48. 	SOCKADDR_IN addrCli;
    49. 	int len = sizeof(SOCKADDR);
    50.  
    51. 	char recvBuf[100];
    52. 	char sendBuf[100];
    53. 	while (true) {
    54. 		//接收链接请求，返回针对客户端的套接字
    55. 		SOCKET sockConn = accept(sockSrv,
    56. 			(SOCKADDR*)&addrCli, &len);
    57.  
    58. 		closesocket(sockConn);
    59. 	}
    60.  
    61. 	//关闭套接字
    62. 	closesocket(sockSrv);
    63. 	//清理套接字库
    64. 	WSACleanup();
    65. 	system("pause");
    66. }

    服务器要对每个连接的客户端进行维护，所以我们要创建一个全局数组去保存这些连接客户端的Socket，同时也要声明一个整型的全局变量，用来记录已经连接的客户端数量。

    1. //客户端socket数组
    2. #define MAXSIZE 256
    3. SOCKET clntSocks[MAXSIZE];
    4.  
    5. int clntCnt = 0;//记录已经连接的客户端数量

    因为我们会有多个线程去访问这些全局变量，所以应添加互斥对象，保证每个线程能单独访问这些临界资源。 

    1. HANDLE hMutex;
    2. hMutex = CreateMutex(NULL, FALSE, NULL);

    每当有一个客户端连接，将客户端Socket保存在数组中，服务端再起一个线程去维护这个Socket。Socket数组是全局变量，所以在访问数组前先去申请临界资源的访问权。

    1. while (true) {
    2. 	//接收链接请求，返回针对客户端的套接字
    3. 	SOCKET sockConn = accept(sockSrv, 
    4. 		(SOCKADDR*)&addrCli, &len);
    5.  
    6. 	//每来一个连接，全局数组应该加一个成员，最大连接数+1
    7. 	WaitForSingleObject(hMutex,INFINITE);
    8.     //放到Socket数组中
    9. 	clntSocks[clntCnt++] = sockConn;
    10. 	ReleaseMutex(hMutex);
    11.  
    12. 	//客户端每来一个连接，服务端起一个线程
    13. 	hThread = (HANDLE)_beginthreadex(NULL, 0, 
    14. 		HandleCln, (void*)&sockConn, 0, NULL);
    15.  
    16. 	printf("Connect client IP :%s\n", inet_ntoa(addrCli.sin_addr));
    17. 	WaitForSingleObject(hMutex, INFINITE);
    18. 	printf("Connect client num :%d\n", clntCnt);
    19. 	ReleaseMutex(hMutex);
    20. }

    HandleCln是一个自定义的线程函数，负责去维护连接的客户端；接收客户端发送的信息并转发给其他客户端；以及客户端关闭连接时处理断开连接。

    1. unsigned WINAPI HandleCln(void* arg) {
    2. 	//1.接收传递过来的客户端socket
    3. 	SOCKET hClntSock = *(SOCKET*)arg;
    4.  
    5. 	int iLen = 0, i;
    6. 	char szMsg[MAXSIZE] = { 0 };
    7. 	//2进行数据的收发，循环接收
    8. 	//接收到客户端的数据
    9. 	//recv会一直等待数据接收，接收成功后返回数据的字节数，否则返回一些对应错误
    10. 	while (true) {
    11. 		iLen = recv(hClntSock, szMsg, sizeof(szMsg), 0);
    12. 		if (iLen != -1) {
    13. 			//将接收到的数据发送给所有客户端
    14. 			SendMsg(szMsg, iLen);
    15. 		}
    16. 		else {
    17. 			break;
    18. 		}
    19. 		
    20. 	}
    21. 	//3.处理断开连接
    22. 	WaitForSingleObject(hMutex, INFINITE);
    23. 	for (i = 0; i < clntCnt; i++) {
    24. 		//遍历socket数组
    25. 		if (hClntSock == clntSocks[i]) {
    26. 			//将该socket剔除
    27. 			while (i < clntCnt) {
    28. 				clntSocks[i] = clntSocks[i + 1];
    29. 				i++;
    30. 			}
    31. 			break;
    32. 		}
    33. 	}
    34. 	//最大连接数-1
    35. 	clntCnt--;
    36. 	printf("此时连接数目：%d", clntCnt);
    37. 	ReleaseMutex(hMutex);
    38. 	//关闭该套接字
    39. 	closesocket(hClntSock);
    40. 	return 0;
    41. }

    HandleCln函数将客户端发送的信息调用SendMsg函数转发给其他客户端，当客户端断开连接，此时就要更新Socket数组和记录连接数的变量，因为属于全局变量，所以要在访问前先去申请对临界资源的访问。

    SendMsg函数

    1. //发送给所有的客户端
    2. void SendMsg(char* szMsg, int iLen) {
    3. 	int i = 0;
    4. 	WaitForSingleObject(hMutex, INFINITE);
    5. 	for (i = 0; i < clntCnt; i++) {
    6. 		send(clntSocks[i], szMsg, iLen, 0);
    7. 	}
    8. 	ReleaseMutex(hMutex);
    9. }

    当有多个线程去调用这个函数时，每个线程都有自己的栈空间，因此函数中的局部变量不受影响，但函数中如果使用了全局变量则需要加锁。 

    完整代码

    1. #include 
    2. #include//第二版本的网络库
    3. #include
    4. #include
    5. #pragma comment(lib,"ws2_32.lib")
    6.  
    7. //服务端的设计
    8. //1.每来一个连接，服务端起一个线程去维护
    9. //2.将收到的消息转发给所有的客户端
    10. //3，断开某个连接，需要处理断开的连接
    11.  
    12. //客户端socket数组
    13. #define MAXSIZE 256
    14. SOCKET clntSocks[MAXSIZE];
    15.  
    16. HANDLE hMutex;
    17.  
    18. int clntCnt = 0;//记录已经连接的客户端数量
    19. //处理客户端连接的函数
    20.  
    21. //发送给所有的客户端
    22. //多个线程去调用这个函数时
    23. //每个线程都有自己的栈空间，因此函数中的局部变量会保存在不同的栈上，因此互不影响
    24. //而函数中有全局变量时则必须给变量加锁
    25. void SendMsg(char* szMsg, int iLen) {
    26. 	int i = 0;
    27. 	WaitForSingleObject(hMutex, INFINITE);
    28. 	for (i = 0; i < clntCnt; i++) {
    29. 		send(clntSocks[i], szMsg, iLen, 0);
    30. 	}
    31. 	ReleaseMutex(hMutex);
    32. }
    33.  
    34. unsigned WINAPI HandleCln(void* arg) {
    35. 	//1.接收传递过来的客户端socket
    36. 	SOCKET hClntSock = *(SOCKET*)arg;
    37.  
    38. 	int iLen = 0, i;
    39. 	char szMsg[MAXSIZE] = { 0 };
    40. 	//2进行数据的收发，循环接收
    41. 	//接收到客户端的数据
    42. 	//recv会一直等待数据接收，接收成功后返回数据的字节数，否则返回一些对应错误
    43. 	while (true) {
    44. 		iLen = recv(hClntSock, szMsg, sizeof(szMsg), 0);
    45. 		if (iLen != -1) {
    46. 			//将接收到的数据发送给所有客户端
    47. 			SendMsg(szMsg, iLen);
    48. 		}
    49. 		else {
    50. 			break;
    51. 		}
    52. 		
    53. 	}
    54. 	//3.处理断开连接
    55. 	WaitForSingleObject(hMutex, INFINITE);
    56. 	for (i = 0; i < clntCnt; i++) {
    57. 		//遍历socket数组
    58. 		if (hClntSock == clntSocks[i]) {
    59. 			//将该socket剔除
    60. 			while (i < clntCnt) {
    61. 				clntSocks[i] = clntSocks[i + 1];
    62. 				i++;
    63. 			}
    64. 			break;
    65. 		}
    66. 	}
    67. 	//最大连接数-1
    68. 	clntCnt--;
    69. 	printf("此时连接数目：%d", clntCnt);
    70. 	ReleaseMutex(hMutex);
    71. 	//关闭该套接字
    72. 	closesocket(hClntSock);
    73. 	return 0;
    74. }
    75.  
    76.  
    77.  
    78. int main() {
    79. 	//初始化套接字库
    80. 	WORD wVersion;
    81. 	WSADATA wsaData;
    82. 	int err;
    83.  
    84.  
    85. 	//
    86. 	HANDLE hThread;
    87.  
    88. 	wVersion = MAKEWORD(1, 1);  //MAKEWORD(a,b) b|a<<8
    89. 	err = WSAStartup(wVersion, &wsaData);
    90. 	//检查1
    91. 	if (err != 0) {
    92. 		return err;
    93. 	}
    94. 	//检查2
    95. 	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
    96. 		//清理套接字库
    97. 		WSACleanup();
    98. 		return -1;
    99. 	}
    100.  
    101. 	//创建一个互斥对象 
    102. 	hMutex = CreateMutex(NULL, FALSE, NULL);
    103.  
    104.  
    105. 	//创建tcp套接字
    106. 	SOCKET sockSrv = socket(AF_INET, SOCK_STREAM, 0);
    107. 	//绑定到本机
    108. 	//绑定即要指明绑定的哪个IP地址，同时指明绑定的端口号
    109. 	//准备绑定信息
    110. 	SOCKADDR_IN addrSrv;
    111. 	addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
    112. 	//协议族，与上面保持一致
    113. 	addrSrv.sin_family = AF_INET;
    114. 	//端口；0~65535，其中1024以下的端口为系统保留的
    115. 	addrSrv.sin_port = htons(6000);
    116. 	//绑定
    117. 	if (bind(sockSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR)) == SOCKET_ERROR) {
    118.  
    119. 		printf("bind ERROR ERRORnum=%d\n", GetLastError());
    120. 	}
    121.  
    122. 	//监听
    123. 	//linsten用来监听该端口上的连接数，当执
    124. 	if (listen(sockSrv, 10) == SOCKET_ERROR) {
    125. 		printf("linten ERROR ROOROnum=%d\n", GetLastError());
    126. 	}
    127. 	std::cout << "Server start at 6000" << std::endl;
    128.  
    129. 	//接收请求前的准备工作
    130. 	SOCKADDR_IN addrCli;
    131. 	int len = sizeof(SOCKADDR);
    132.  
    133. 	char recvBuf[100];
    134. 	char sendBuf[100];
    135. 	while (true) {
    136. 		//接收链接请求，返回针对客户端的套接字
    137. 		SOCKET sockConn = accept(sockSrv,
    138. 			(SOCKADDR*)&addrCli, &len);
    139.  
    140. 		//每来一个连接，全局数组应该加一个成员，最大连接数+1
    141. 		WaitForSingleObject(hMutex, INFINITE);
    142. 		clntSocks[clntCnt++] = sockConn;
    143.  
    144. 		ReleaseMutex(hMutex);
    145.  
    146. 		//客户端每来一个连接，服务端起一个线程
    147. 		hThread = (HANDLE)_beginthreadex(NULL, 0,
    148. 			HandleCln, (void*)&sockConn, 0, NULL);
    149.  
    150. 		printf("Connect client IP :%s\n", inet_ntoa(addrCli.sin_addr));
    151. 		WaitForSingleObject(hMutex, INFINITE);
    152. 		printf("Connect client num :%d\n", clntCnt);
    153. 		ReleaseMutex(hMutex);
    154. 	}
    155.  
    156. 	//关闭套接字
    157. 	closesocket(sockSrv);
    158. 	//清理套接字库
    159. 	WSACleanup();
    160. 	system("pause");
    161. }

    客户端

    同理，先准备一个客户端的模板 

    TCP套接字编程详解

    1. #include 
    2. #include//第二版本的网络库
    3. #pragma comment(lib,"ws2_32.lib")
    4.  
    5. #include 
    6.  
    7. int main() {
    8. 	//初始化套接字库
    9. 	WORD wVersion;
    10. 	WSADATA wsaData;
    11. 	int err;
    12. 	wVersion = MAKEWORD(1, 1);  //MAKEWORD(a,b) b|a<<8
    13. 	err = WSAStartup(wVersion, &wsaData);
    14. 	//检查1
    15. 	if (err != 0) {
    16. 		return err;
    17. 	}
    18. 	//检查2
    19. 	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
    20. 		//清理套接字库
    21. 		WSACleanup();
    22. 		return -1;
    23. 	}
    24.  
    25. 	//创建tcp套接字，与服务器保持一致
    26. 	SOCKET sockCli = socket(AF_INET, SOCK_STREAM, 0);
    27. 	//准备连接信息
    28. 	//指明要连接的IP地址和端口号
    29. 	SOCKADDR_IN addrSrv;
    30. 	addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    31. 	//协议族，与上面保持一致
    32. 	addrSrv.sin_family = AF_INET;
    33. 	//端口；0~65535，其中1024以下的端口为系统保留的
    34. 	addrSrv.sin_port = htons(6000);
    35.  
    36. 	//连接服务器
    37. 	connect(sockCli, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));
    38.  
    39. 	//发送的数据
    40. 	char sendBuf[] = "world";
    41. 	//接收的数据
    42. 	char recvBuf[100];
    43. 	//发送数据到服务器
    44. 	send(sockCli, sendBuf, strlen(sendBuf) + 1, 0);
    45. 	//接收数据到服务器
    46. 	recv(sockCli, recvBuf, sizeof(recvBuf), 0);
    47.  
    48. 	std::cout << recvBuf << std::endl;
    49. 	//关闭套接字
    50. 	closesocket(sockCli);
    51. 	WSACleanup();
    52.  
    53. 	system("pause");
    54. 	return 0;
    55. }

    我们将main函数写成带参形式，在运行时传入一个字符串、来作为客户端的用户名。为此，我们需要准本一个字符数组来存储这个用户名。

    1. #define NAME_SIZE 20
    2. char szName[NAME_SIZE] = "[DEFAULT]";
    3.  
    4.  
    5. int main(int argc,char * argv){
    6.     //保存用户名
    7.     sprintf(szName,argv);
    8.  
    9.     return 0;
    10. }

    这样我们就可应通过命令行的形式运行这个程序时传入一个字符串来作为用户的名称。 

    当客户端与服务器连接成功后，我们就要起两个线程去处理接收和发送数据的任务。等到两个线程都执行完毕，我们就可应清空套接字库，结束掉main函数。

    1. //连接服务器
    2. if (connect(sockCli, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR)) == SOCKET_ERROR) {
    3. 	printf("connect error error code：=%d", GetLastError());
    4. 	return -1;
    5. }
    6.  
    7. //发送消息	起一个线程
    8. hSendThread = (HANDLE)_beginthreadex(NULL, 0, SendMsg ,
    9. 	(void*)&sockCli, 0, NULL);
    10.  
    11. hRecvThread = (HANDLE)_beginthreadex(NULL, 0, RecvMsg,
    12. 	(void*)&sockCli, 0, NULL);
    13.  
    14. //等待内核对象的变化
    15. WaitForSingleObject(hSendThread, INFINITE);
    16. WaitForSingleObject(hRecvThread, INFINITE);
    17. 	 
    18. WSACleanup();
    19.  
    20. 	
    21. return 0;

    SendMsg是我们自定义的线程函数，负责去向服务器发送数据，他会一直从控制台中读取数据然后保存在一个数组缓冲区中。

    我们规定如果用户输入了“q/n”或者“Q/n”就表明与服务器断开连接，因此在读取完后要进行判断。

    发送数据的格式为：[用户名] 消息

    1. unsigned WINAPI SendMsg(void* arg) {
    2. 	SOCKET hClntSock = *(SOCKET*)arg;
    3. 	//名字和消息的组合
    4. 	char szNameMsg[NAME_SIZE + BUF_SIZE];
    5. 	//循环接收来自控制台的消息
    6. 	while (true) {
    7. 		//接收控制台应用
    8. 		fgets(szMsg,BUF_SIZE,stdin);
    9. 		//当收到q或Q，退出
    10. 		if (!strcmp(szMsg, "Q\n") || !strcmp(szMsg, "q\n")) {
    11. 			closesocket(hClntSock);
    12. 			exit(0);
    13. 		}
    14. 		//准备发送的数据
    15. 		sprintf(szNameMsg, "%s %s", szName, szMsg);//字符串拼接
    16. 		//发送给服务端
    17. 		send(hClntSock, szNameMsg, strlen(szNameMsg), 0);
    18.  
    19. 	}
    20. 	return 0;
    21. }

     RecvMsg是我们自定义的线程函数，负责接收服务器发送的数据，并显示在控制台上。当客户端和服务器保存连接，当服务器并未发送数据时，线程会一直阻塞在recv那里，直到有数据发送过来。当与客户端断开连接时，recv会返回-1。

    1. //接收数据
    2. unsigned WINAPI RecvMsg(void* arg) {
    3. 	SOCKET hClntSock = *(SOCKET*)arg;
    4. 	
    5. 	char szNameMsg[NAME_SIZE + BUF_SIZE];
    6. 	int iLen = 0;
    7. 	while (true) {
    8. 		iLen = recv(hClntSock, szNameMsg, NAME_SIZE + BUF_SIZE - 1, 0);
    9. 		//服务器断开
    10. 		if (iLen == -1) {
    11. 			return -1;
    12. 		}
    13. 		//从第0待iLen-1的位置都是收到的数据
    14. 		szNameMsg[iLen] = 0;
    15. 		//输出到控制台，printf函数也可以
    16. 		fputs(szNameMsg, stdout);
    17.  
    18. 	}
    19. 	return 0;
    20. }

    完整代码

    1. //1.接收与发送数据，（起一个线程负责
    2. // 2.断开连接               
    3. #include 
    4. #include//第二版本的网络库
    5. #include
    6. #include
    7. #pragma comment(lib,"ws2_32.lib")
    8.  
    9. //最大缓冲区大小
    10. #define BUF_SIZE 256
    11. #define NAME_SIZE 20
    12.  
    13.  
    14.  
    15. char szName[NAME_SIZE] = "[DEFAULT]";
    16. char szMsg[BUF_SIZE];
    17.  
    18. //发送数据
    19. unsigned WINAPI SendMsg(void* arg) {
    20. 	SOCKET hClntSock = *(SOCKET*)arg;
    21. 	//名字和消息的组合
    22. 	char szNameMsg[NAME_SIZE + BUF_SIZE];
    23. 	//循环接收来自控制台的消息
    24. 	while (true) {
    25. 		//接收控制台应用
    26. 		fgets(szMsg,BUF_SIZE,stdin);
    27. 		//当收到q或Q，退出
    28. 		if (!strcmp(szMsg, "Q\n") || !strcmp(szMsg, "q\n")) {
    29. 			closesocket(hClntSock);
    30. 			exit(0);
    31. 		}
    32. 		//准备发送的数据
    33. 		sprintf(szNameMsg, "%s %s", szName, szMsg);//字符串拼接
    34. 		//发送给服务端
    35. 		send(hClntSock, szNameMsg, strlen(szNameMsg), 0);
    36.  
    37. 	}
    38. 	return 0;
    39. }
    40.  
    41.  
    42.  
    43. //接收数据
    44. unsigned WINAPI RecvMsg(void* arg) {
    45. 	SOCKET hClntSock = *(SOCKET*)arg;
    46. 	
    47. 	char szNameMsg[NAME_SIZE + BUF_SIZE];
    48. 	int iLen = 0;
    49. 	while (true) {
    50. 		iLen = recv(hClntSock, szNameMsg, NAME_SIZE + BUF_SIZE - 1, 0);
    51. 		//服务器断开
    52. 		if (iLen == -1) {
    53. 			return -1;
    54. 		}
    55. 		//从第0待iLen-1的位置都是收到的数据
    56. 		szNameMsg[iLen] = 0;
    57. 		//输出到控制台，printf函数也可以
    58. 		fputs(szNameMsg, stdout);
    59.  
    60. 	}
    61. 	return 0;
    62. }
    63.  
    64.  
    65. //待参数的main函数，用命令行启动，在当前目录按下shift+鼠标右键 cmd
    66. int main(int argc,char *argv[]) {
    67. 	//初始化套接字库
    68. 	WORD wVersion;
    69. 	WSADATA wsaData;
    70. 	int err;
    71. 	HANDLE hSendThread, hRecvThread;//负责收发信息
    72.  
    73.  
    74. 	wVersion = MAKEWORD(1, 1);  //MAKEWORD(a,b) b|a<<8
    75. 	err = WSAStartup(wVersion, &wsaData);
    76. 	//检查1
    77. 	if (err != 0) {
    78. 		return err;
    79. 	}
    80. 	//检查2
    81. 	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
    82. 		//清理套接字库
    83. 		WSACleanup();
    84. 		return -1;
    85. 	}
    86.  
    87. 	sprintf(szName, "[%s]", argv[1]);
    88.  
    89.  
    90. 	//创建tcp套接字，与服务器保持一致
    91. 	SOCKET sockCli = socket(AF_INET, SOCK_STREAM, 0);
    92. 	//准备连接的信息
    93. 	//指明连接的IP地址和端口号
    94. 	SOCKADDR_IN addrSrv;
    95. 	addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    96. 	//协议族，与上面保持一致
    97. 	addrSrv.sin_family = AF_INET;
    98. 	//端口；0~65535，其中1024以下的端 口为系统保留的
    99. 	addrSrv.sin_port = htons(6000);
    100.  
    101. //连接服务器
    102. if (connect(sockCli, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR)) == SOCKET_ERROR) {
    103. 	printf("connect error error code：=%d", GetLastError());
    104. 	return -1;
    105. }
    106.  
    107. //发送消息	起一个线程
    108. hSendThread = (HANDLE)_beginthreadex(NULL, 0, SendMsg ,
    109. 	(void*)&sockCli, 0, NULL);
    110.  
    111. hRecvThread = (HANDLE)_beginthreadex(NULL, 0, RecvMsg,
    112. 	(void*)&sockCli, 0, NULL);
    113.  
    114. //等待内核对象的变化
    115. WaitForSingleObject(hSendThread, INFINITE);
    116. WaitForSingleObject(hRecvThread, INFINITE);
    117. 	 
    118. WSACleanup();
    119.  
    120. 	
    121. return 0;
    122. }

    通过命令行运行程序

     我们去到.exe的文件目录下

    在该目录下，按住shift+鼠标右键， 选择“在此处打开PowerShell窗口”

    在该窗口下，我们输入“./程序名称” ，然后空格，输入向main函数传入的参数就可以运行这个程序了。

     

  • 相关阅读:
    树莓派系统文件解析
    windows下安装zookeeper及kafka
    【机器人学导论（第四版）】1-绪论
    Redis入门完整教程：发布订阅
    文心大模型写TodoList项目需求
    6月B站和微博达人涨粉榜单，微博涨粉榜一竟是TA
    码农跃迁三角色：程序员、技术主管与架构师
    【Vue】Vue对接SpringBoot接口完整代码
    WPF网格类型像素着色器
    Vue3从入门到实战：掌握状态管理库pinia（下部分）
  • 原文地址：https://blog.csdn.net/qq_54169998/article/details/127709837