Linux C利用Socket套接字进行服务器与多个客户端进行通讯

待我称王封你为后i 2022-06-06 02:15 166阅读 0赞

[http://blog.csdn.net/returningprodigal/article/details/51916754][http_blog.csdn.net_returningprodigal_article_details_51916754]

## 服务器端 ##

**\[html\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  \#include **<****stdlib.h****>**
2.  \#include **<****sys**/types.h**>**
3.  \#include **<****stdio.h****>**
4.  \#include **<****sys**/socket.h**>**
5.  \#include **<****string.h****>**
6.  \#include **<****signal.h****>**
7.  \#include **<****arpa**/inet.h**>**
8.  \#include **<****unistd.h****>**
9.  \#include **<****pthread.h****>**
10. //服务器端 
11. 
12. void \*fun\_thrReceiveHandler(void \*socketInfo); 
13. void \*fun\_thrAcceptHandler(void \*socketListen); 
14. //1:是 0：否 
15. int checkThrIsKill(pthread\_t thr); 
16. 
17. typedef struct MySocketInfo\{ 
18.  int socketCon; 
19.  char \*ipaddr; 
20.  uint16\_t port; 
21. \}\_MySocketInfo; 
22. 
23. // 客户端数组 
24. struct MySocketInfo arrConSocket\[10\]; 
25. int conClientCount = 0; 
26. 
27. // 接受客户端线程列表 
28. pthread\_t arrThrReceiveClient\[10\]; 
29. int thrReceiveClientCount = 0; 
30. 
31. int main() 
32. \{ 
33.  //初始化全局变量 
34.  //memset(arrConSocket,0,sizeof(struct MySocketInfo)\*10); 
35. 
36.  printf("开始socket\\n"); 
37.  /\* 创建TCP连接的Socket套接字 \*/ 
38.  int socketListen = socket(AF\_INET, SOCK\_STREAM, 0); 
39.  if(socketListen **<****0**)\{ 
40.  printf("创建TCP套接字失败\\n"); 
41.  exit(-1); 
42.  \}else\{ 
43.  printf("创建套接字成功\\n"); 
44.  \} 
45.  /\* 填充服务器端口地址信息，以便下面使用此地址和端口监听 \*/ 
46.  struct sockaddr\_in server\_addr; 
47.  bzero(&server\_addr,sizeof(struct sockaddr\_in)); 
48. server\_addr.sin\_family=AF\_INET; 
49. server\_addr.sin\_addr.s\_addr=htonl(INADDR\_ANY); /\* 这里地址使用全0，即所有 \*/ 
50. server\_addr.sin\_port=htons(2000); 
51.  if(bind(socketListen, (struct sockaddr \*)&server\_addr,sizeof(struct sockaddr)) != 0)\{ 
52.  perror("绑定ip地址、端口号失败\\n"); 
53.  exit(-1); 
54.  \}else\{ 
55.  printf("绑定ip地址,端口号\\n"); 
56.  \} 
57.  /\* 开始监听相应的端口 \*/ 
58.  if(listen(socketListen, 10) != 0)\{ 
59.  printf("开启监听失败\\n"); 
60.  exit(-1); 
61.  \}else\{ 
62.  printf("开启监听成功\\n"); 
63.  \} 
64.  /\* 接受连接套接字 \*/ 
65.  pthread\_t thrAccept; 
66.  pthread\_create(&thrAccept,NULL,fun\_thrAcceptHandler,&socketListen); 
67. 
68.  /\* 实时发送数据 \*/ 
69.  while(1)\{ 
70.  //判断线程存活多少 
71.  int i; 
72.  for(i=0;i**<****thrReceiveClientCount**;i++)\{ 
73.  if(checkThrIsKill(arrThrReceiveClient\[i\]) == 1)\{ 
74.  printf("有个线程被杀了\\n"); 
75.  thrReceiveClientCount--; 
76.  \} 
77.  \} 
78.  printf("当前有接受数据线程多少个：%d\\n",thrReceiveClientCount); 
79. 
80.  // 可以录入用户操作选项，并进行相应操作 
81.  char userStr\[30\] = \{'0'\}; 
82.  scanf("%s",userStr); 
83.  if(strcmp(userStr,"q") == 0)\{ 
84.  printf("用户选择退出！\\n"); 
85.  break; 
86.  \} 
87.  // 发送消息 
88.  if(conClientCount **<**= 0)\{ 
89.  printf("没有客户端连接\\n"); 
90.  \}else\{ 
91.  int i; 
92.  for(i=0; i**<****conClientCount**; i++)\{ 
93.  //int sendMsg\_len = send(arrConSocket\[i\].socketCon, userStr, 30, 0); 
94.  int sendMsg\_len = write(arrConSocket\[i\].socketCon,userStr,30); 
95.  if(sendMsg\_len **>** 0)\{ 
96.  printf("向%s:%d发送成功\\n",arrConSocket\[i\].ipaddr,arrConSocket\[i\].port); 
97.  \}else\{ 
98.  printf("向%s:%d发送失败\\n",arrConSocket\[i\].ipaddr,arrConSocket\[i\].port); 
99.  \} 
100.  \} 
101.  \} 
102. 
103.  sleep(0.5); 
104.  \} 
105. 
106.  // 等待子进程退出 
107.  printf("等待子线程退出，即将退出！\\n"); 
108.  char \*message; 
109.  pthread\_join(thrAccept,(void \*)&message); 
110.  printf("%s\\n",message); 
111. 
112.  return 0; 
113. \} 
114. 
115. void \*fun\_thrReceiveHandler(void \*socketCon)\{ 
116.  char buffer\[30\]; 
117.  int buffer\_length; 
118.  int \_socketCon; 
119.  while(1)\{ 
120.  //添加对buffer清零 
121.  bzero(&buffer,sizeof(buffer)); 
122. \_socketCon = \*((int \*)socketCon); 
123.  sleep(0.1); 
124.  printf("接受数据线程中，连接套接字为%d\\n",\_socketCon); 
125. 
126. buffer\_length = read(\_socketCon,buffer,30); 
127.  if(buffer\_length == 0)\{ 
128.  printf("%d 客户端关闭\\n",\_socketCon); 
129.  conClientCount--; 
130.  break; 
131.  \}else if(buffer\_length **<****0**)\{ 
132.  printf("接受客户端数据失败\\n"); 
133.  break; 
134.  \} 
135.  buffer\[buffer\_length\] = '\\0'; 
136.  printf("%d 说：%s\\n",\_socketCon,buffer); 
137. 
138. 
139.  //获取当前线程id 
140.  //printf("当前线程id:%ld",pthread\_self()); 
141. 
142. 
143.  sleep(0.2); 
144.  \} 
145.  printf("接受数据线程结束了\\n"); 
146.  return NULL; 
147. \} 
148. 
149. void \*fun\_thrAcceptHandler(void \*socketListen)\{ 
150.  while(1)\{ 
151.  int sockaddr\_in\_size = sizeof(struct sockaddr\_in); 
152.  struct sockaddr\_in client\_addr; 
153.  int \_socketListen = \*((int \*)socketListen); 
154.  int socketCon = accept(\_socketListen, (struct sockaddr \*)(&client\_addr), (socklen\_t \*)(&sockaddr\_in\_size)); 
155.  if(socketCon **<****0**)\{ 
156.  printf("连接失败\\n"); 
157.  \}else\{ 
158.  printf("连接成功 ip: %s:%d\\r\\n",inet\_ntoa(client\_addr.sin\_addr),client\_addr.sin\_port); 
159.  \} 
160.  printf("连接套接字为：%d\\n",socketCon); 
161.  //开启新的通讯线程，负责同连接上来的客户端进行通讯 
162.  \_MySocketInfo socketInfo; 
163. socketInfo.socketCon = socketCon; 
164. socketInfo.ipaddr = inet\_ntoa(client\_addr.sin\_addr); 
165. socketInfo.port = client\_addr.sin\_port; 
166.  arrConSocket\[conClientCount\] = socketInfo; 
167.  conClientCount++; 
168.  printf("连接了%d个用户\\n",conClientCount); 
169. 
170.  pthread\_t thrReceive = 0; 
171.  pthread\_create(&thrReceive,NULL,fun\_thrReceiveHandler,&socketCon); 
172.  arrThrReceiveClient\[thrReceiveClientCount\] = thrReceive; 
173.  thrReceiveClientCount++; 
174. 
175.  //让进程休息1秒 
176.  sleep(0.5); 
177.  \} 
178. 
179.  char \*s = "安全退出接受进程"; 
180.  pthread\_exit(s); 
181. \} 
182. 
183. int checkThrIsKill(pthread\_t thr)\{ 
184.  int res = 1; 
185.  int res\_kill = pthread\_kill(thr,0); 
186.  if(res\_kill == 0)\{ 
187. res = 0; 
188.  \} 
189.  return res; 
190. \}

## 客户端 ##

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  \#include <stdlib.h>
2.  \#include <sys/types.h>
3.  \#include <stdio.h>
4.  \#include <sys/socket.h>
5.  \#include <string.h>
6.  \#include <arpa/inet.h>
7.  \#include <unistd.h>
8.  \#include <pthread.h>
9.  
10. **typedef****struct** MySocketInfo\{ 
11. **int** socketCon; 
12.  unsigned **long** ipaddr; 
13.  unsigned **short** port; 
14. \}\_MySocketInfo; 
15. 
16. **void** \*fun\_thrReceiveHandler(**void** \*socketCon); 
17. 
18. **int** main() 
19. \{ 
20.  printf("开始socket\\n"); 
21. /\* 创建TCP连接的Socket套接字 \*/
22. **int** socketCon = socket(AF\_INET, SOCK\_STREAM, 0); 
23. **if**(socketCon < 0)\{ 
24.  printf("创建TCP连接套接字失败\\n"); 
25.  exit(-1); 
26.  \} 
27. /\* 填充客户端端口地址信息，以便下面使用此地址和端口监听 \*/
28. **struct** sockaddr\_in server\_addr; 
29.  bzero(&server\_addr,**sizeof**(**struct** sockaddr\_in)); 
30.  server\_addr.sin\_family=AF\_INET; 
31.  server\_addr.sin\_addr.s\_addr=inet\_addr("127.0.0.1"); 
32.  server\_addr.sin\_port=htons(2000); 
33.  printf("连接之前的socketCon:%d",socketCon); 
34. /\* 连接服务器 \*/
35. **int** res\_con = connect(socketCon,(**struct** sockaddr \*)(&server\_addr),**sizeof**(**struct** sockaddr)); 
36. **if**(res\_con != 0)\{ 
37.  printf("连接失败\\n"); 
38.  exit(-1); 
39.  \} 
40.  printf("连接成功\\n"); 
41. //开启新的实时接受数据线程
42.  pthread\_t thrReceive; 
43.  pthread\_create(&thrReceive,NULL,fun\_thrReceiveHandler,&socketCon); 
44. 
45. /\* 实时发送数据 \*/
46. **while**(1)\{ 
47. //char userStr\[30\] = \{'\\0'\};
48. **char** \*userStr = "woaini"; 
49. // 可以录入用户操作选项，并进行相应操作
50. //scanf("%s",userStr);
51. //if(strcmp(userStr,"q") == 0)\{ 
52. //printf("用户选择退出！\\n");
53. //break;
54. //\}
55. // 发送消息
56. //int sendMsg\_len = send(socketCon, userStr, 30, 0);
57.  printf("-发送之前-\\n"); 
58. **int** sendMsg\_len = write(socketCon,userStr,30); 
59. **if**(sendMsg\_len > 0)\{ 
60.  printf("发送成功,客户端套接字:%d\\n",socketCon); 
61.  \}**else**\{ 
62.  printf("发送失败\\n"); 
63.  \} 
64. 
65.  sleep(2); 
66.  \} 
67. 
68. // 关闭套接字
69.  close(socketCon); 
70. **return** 0; 
71. \} 
72. 
73. **void** \*fun\_thrReceiveHandler(**void** \*socketCon)\{ 
74. **while**(1)\{ 
75. **char** buffer\[30\]; 
76. **int** \_socketCon = \*((**int** \*)socketCon); 
77. //int buffer\_length = recv(\_socketCon,buffer,30,0);
78. **int** buffer\_length = read(\_socketCon,buffer,30); 
79.  buffer\[buffer\_length\] = '\\0'; 
80.  printf("服务器说:%s\\n",buffer); 
81.  \} 
82. **return** NULL; 
83. \}

### 代码思路：服务器端：首先创建监听的套接字，然后创建用于（循环检测客户端连接）的新线程，当检测到有客户端连接，则创建一个新的线程负责同这个套接字通讯，即接受这个套接字发送过来的消息。 ###

### 现象：单个客户端同服务器可以进行通讯，当连接上多个客户端过后，服务器端能够群发消息，最后连接的客户端向服务器发送的消息能够接受到，但之前的所有的客户端向服务器发送消息均不能收到。 ###

### 解决思路：先使用排除法，首先找到了一份正确的客户端代码，连接上我自己写的服务器，也出现了同样的错误，所以可以排除我自己写的客户端。最终到了服务器端。服务器中，因为单个客户端可以与服务器通讯，所以检测连接的线程没有问题，那么最终归结到了循环接受客户端数据的线程。那着正确的服务器接受客户端数据的代码同自己写的对照，哈哈，发现了问题，是\_socketCon值的问题，\_socketCon的赋值是通过指针，然后打印这个值，发现这个值在不断变化，并且在检测连接的线程中定义的 int socketCon 值正是这个，而这个值是在 while死循环中不停的创建，不停的销毁！哇咔咔，真相终于大白与天下，功夫不负有心人啊，查了一天半的bug终于被我查出来了！ ###

*总结：*

*1、在死循环中切记不要定义变量，最好是在死循环之外定义变量，在死循环中使用！*

*2、在函数有死循环时，值只有一个的局部变量，就在死循环之上定义并初始化！就不要在死循环中赋值，只是去使用它就好了！*

*3、在创建多线程给多线程处理函数传参数中，切记不要传入生命周期较短的指针变量，传入值类型都好！*

## 服务器与多个客户端通讯的正确代码如下： ##

服务器端

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  \#include <stdlib.h>
2.  \#include <sys/types.h>
3.  \#include <stdio.h>
4.  \#include <sys/socket.h>
5.  \#include <string.h>
6.  \#include <signal.h>
7.  \#include <arpa/inet.h>
8.  \#include <unistd.h>
9.  \#include <pthread.h>
10. //服务器端
11. 
12. **void** \*fun\_thrReceiveHandler(**void** \*socketInfo); 
13. **void** \*fun\_thrAcceptHandler(**void** \*socketListen); 
14. //1:是 0：否
15. **int** checkThrIsKill(pthread\_t thr); 
16. 
17. **typedef****struct** MySocketInfo\{ 
18. **int** socketCon; 
19. **char** \*ipaddr; 
20.  uint16\_t port; 
21. \}\_MySocketInfo; 
22. 
23. // 客户端数组
24. **struct** MySocketInfo arrConSocket\[10\]; 
25. **int** conClientCount = 0; 
26. 
27. // 接受客户端线程列表
28. pthread\_t arrThrReceiveClient\[10\]; 
29. **int** thrReceiveClientCount = 0; 
30. 
31. **int** main() 
32. \{ 
33. //初始化全局变量
34. //memset(arrConSocket,0,sizeof(struct MySocketInfo)\*10);
35. 
36.  printf("开始socket\\n"); 
37. /\* 创建TCP连接的Socket套接字 \*/
38. **int** socketListen = socket(AF\_INET, SOCK\_STREAM, 0); 
39. **if**(socketListen < 0)\{ 
40.  printf("创建TCP套接字失败\\n"); 
41.  exit(-1); 
42.  \}**else**\{ 
43.  printf("创建套接字成功\\n"); 
44.  \} 
45. /\* 填充服务器端口地址信息，以便下面使用此地址和端口监听 \*/
46. **struct** sockaddr\_in server\_addr; 
47.  bzero(&server\_addr,**sizeof**(**struct** sockaddr\_in)); 
48.  server\_addr.sin\_family=AF\_INET; 
49.  server\_addr.sin\_addr.s\_addr=htonl(INADDR\_ANY); /\* 这里地址使用全0，即所有 \*/
50.  server\_addr.sin\_port=htons(2000); 
51. **if**(bind(socketListen, (**struct** sockaddr \*)&server\_addr,**sizeof**(**struct** sockaddr)) != 0)\{ 
52.  perror("绑定ip地址、端口号失败\\n"); 
53.  exit(-1); 
54.  \}**else**\{ 
55.  printf("绑定ip地址,端口号\\n"); 
56.  \} 
57. /\* 开始监听相应的端口 \*/
58. **if**(listen(socketListen, 10) != 0)\{ 
59.  printf("开启监听失败\\n"); 
60.  exit(-1); 
61.  \}**else**\{ 
62.  printf("开启监听成功\\n"); 
63.  \} 
64. /\* 接受连接套接字 \*/
65.  pthread\_t thrAccept; 
66.  pthread\_create(&thrAccept,NULL,fun\_thrAcceptHandler,&socketListen); 
67. 
68. /\* 实时发送数据 \*/
69. **while**(1)\{ 
70. //判断线程存活多少
71. **int** i; 
72. **for**(i=0;i<thrReceiveClientCount;i++)\{ 
73. **if**(checkThrIsKill(arrThrReceiveClient\[i\]) == 1)\{ 
74.  printf("有个线程被杀了\\n"); 
75.  thrReceiveClientCount--; 
76.  \} 
77.  \} 
78.  printf("当前有接受数据线程多少个：%d\\n",thrReceiveClientCount); 
79. 
80. // 可以录入用户操作选项，并进行相应操作
81. **char** userStr\[30\] = \{ '0'\}; 
82.  scanf("%s",userStr); 
83. **if**(strcmp(userStr,"q") == 0)\{ 
84.  printf("用户选择退出！\\n"); 
85. **break**; 
86.  \} 
87. // 发送消息
88. **if**(conClientCount <= 0)\{ 
89.  printf("没有客户端连接\\n"); 
90.  \}**else**\{ 
91. **int** i; 
92. **for**(i=0; i<conClientCount; i++)\{ 
93. //int sendMsg\_len = send(arrConSocket\[i\].socketCon, userStr, 30, 0);
94. **int** sendMsg\_len = write(arrConSocket\[i\].socketCon,userStr,30); 
95. **if**(sendMsg\_len > 0)\{ 
96.  printf("向%s:%d发送成功\\n",arrConSocket\[i\].ipaddr,arrConSocket\[i\].port); 
97.  \}**else**\{ 
98.  printf("向%s:%d发送失败\\n",arrConSocket\[i\].ipaddr,arrConSocket\[i\].port); 
99.  \} 
100.  \} 
101.  \} 
102. 
103.  sleep(0.5); 
104.  \} 
105. 
106. // 等待子进程退出
107.  printf("等待子线程退出，即将退出！\\n"); 
108. **char** \*message; 
109.  pthread\_join(thrAccept,(**void** \*)&message); 
110.  printf("%s\\n",message); 
111. 
112. **return** 0; 
113. \} 
114. 
115. **void** \*fun\_thrAcceptHandler(**void** \*socketListen)\{ 
116. **while**(1)\{ 
117. **int** sockaddr\_in\_size = **sizeof**(**struct** sockaddr\_in); 
118. **struct** sockaddr\_in client\_addr; 
119. **int** \_socketListen = \*((**int** \*)socketListen); 
120. **int** socketCon = accept(\_socketListen, (**struct** sockaddr \*)(&client\_addr), (socklen\_t \*)(&sockaddr\_in\_size)); 
121. **if**(socketCon < 0)\{ 
122.  printf("连接失败\\n"); 
123.  \}**else**\{ 
124.  printf("连接成功 ip: %s:%d\\r\\n",inet\_ntoa(client\_addr.sin\_addr),client\_addr.sin\_port); 
125.  \} 
126.  printf("连接套接字为：%d\\n",socketCon); 
127. //开启新的通讯线程，负责同连接上来的客户端进行通讯
128.  \_MySocketInfo socketInfo; 
129.  socketInfo.socketCon = socketCon; 
130.  socketInfo.ipaddr = inet\_ntoa(client\_addr.sin\_addr); 
131.  socketInfo.port = client\_addr.sin\_port; 
132.  arrConSocket\[conClientCount\] = socketInfo; 
133.  conClientCount++; 
134.  printf("连接了%d个用户\\n",conClientCount); 
135. 
136.  pthread\_t thrReceive = 0; 
137.  pthread\_create(&thrReceive,NULL,fun\_thrReceiveHandler,&socketInfo); 
138.  arrThrReceiveClient\[thrReceiveClientCount\] = thrReceive; 
139.  thrReceiveClientCount++; 
140. 
141. //让进程休息1秒
142.  sleep(0.5); 
143.  \} 
144. 
145. **char** \*s = "安全退出接受进程"; 
146.  pthread\_exit(s); 
147. \} 
148. 
149. **void** \*fun\_thrReceiveHandler(**void** \*socketInfo)\{ 
150. **char** buffer\[30\]; 
151. **int** buffer\_length; 
152.  \_MySocketInfo \_socketInfo = \*((\_MySocketInfo \*)socketInfo); 
153. **while**(1)\{ 
154. //添加对buffer清零
155.  bzero(&buffer,**sizeof**(buffer)); 
156. 
157.  buffer\_length = read(\_socketInfo.socketCon,buffer,30); 
158. **if**(buffer\_length == 0)\{ 
159.  printf("%s:%d 客户端关闭\\n",\_socketInfo.ipaddr,\_socketInfo.port); 
160.  conClientCount--; 
161. **break**; 
162.  \}**else****if**(buffer\_length < 0)\{ 
163.  printf("接受客户端数据失败\\n"); 
164. **break**; 
165.  \} 
166.  buffer\[buffer\_length\] = '\\0'; 
167.  printf("%s:%d 说：%s\\n",\_socketInfo.ipaddr,\_socketInfo.port,buffer); 
168. 
169.  sleep(0.2); 
170.  \} 
171.  printf("接受数据线程结束了\\n"); 
172. **return** NULL; 
173. \} 
174. 
175. **int** checkThrIsKill(pthread\_t thr)\{ 
176. **int** res = 1; 
177. **int** res\_kill = pthread\_kill(thr,0); 
178. **if**(res\_kill == 0)\{ 
179.  res = 0; 
180.  \} 
181. **return** res; 
182. \}

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

#### 客户端 ####

**\[cpp\]** [view plain][] [copy][view plain]

[print][view plain] [?][view plain]

1.  \#include <stdlib.h>
2.  \#include <sys/types.h>
3.  \#include <stdio.h>
4.  \#include <sys/socket.h>
5.  \#include <string.h>
6.  \#include <arpa/inet.h>
7.  \#include <unistd.h>
8.  \#include <pthread.h>
9.  
10. **typedef****struct** MySocketInfo\{ 
11. **int** socketCon; 
12.  unsigned **long** ipaddr; 
13.  unsigned **short** port; 
14. \}\_MySocketInfo; 
15. 
16. **void** \*fun\_thrReceiveHandler(**void** \*socketCon); 
17. **int** checkThrIsKill(pthread\_t thr); 
18. 
19. **int** main() 
20. \{ 
21.  printf("开始socket\\n"); 
22. /\* 创建TCP连接的Socket套接字 \*/
23. **int** socketCon = socket(AF\_INET, SOCK\_STREAM, 0); 
24. **if**(socketCon < 0)\{ 
25.  printf("创建TCP连接套接字失败\\n"); 
26.  exit(-1); 
27.  \} 
28. /\* 填充客户端端口地址信息，以便下面使用此地址和端口监听 \*/
29. **struct** sockaddr\_in server\_addr; 
30.  bzero(&server\_addr,**sizeof**(**struct** sockaddr\_in)); 
31.  server\_addr.sin\_family=AF\_INET; 
32.  server\_addr.sin\_addr.s\_addr=inet\_addr("127.0.0.1"); /\* 这里地址使用全0，即所有 \*/
33.  server\_addr.sin\_port=htons(2000); 
34. /\* 连接服务器 \*/
35. **int** res\_con = connect(socketCon,(**struct** sockaddr \*)(&server\_addr),**sizeof**(**struct** sockaddr)); 
36. **if**(res\_con != 0)\{ 
37.  printf("连接失败\\n"); 
38.  exit(-1); 
39.  \} 
40.  printf("连接成功,连接结果为：%d\\n",res\_con); 
41. //开启新的实时接受数据线程
42.  pthread\_t thrReceive; 
43.  pthread\_create(&thrReceive,NULL,fun\_thrReceiveHandler,&socketCon); 
44. 
45. /\* 实时发送数据 \*/
46. **while**(1)\{ 
47. //检测接受服务器数据线程是否被杀死
48. 
49. 
50. **char** userStr\[30\] = \{ '0'\}; 
51. // 可以录入用户操作选项，并进行相应操作
52.  scanf("%s",userStr); 
53. **if**(strcmp(userStr,"q") == 0)\{ 
54.  printf("用户选择退出！\\n"); 
55. **break**; 
56.  \} 
57. // 发送消息
58. //int sendMsg\_len = send(socketCon, userStr, 30, 0);
59. **int** sendMsg\_len = write(socketCon,userStr,30); 
60. **if**(sendMsg\_len > 0)\{ 
61.  printf("发送成功,服务端套接字句柄:%d\\n",socketCon); 
62.  \}**else**\{ 
63.  printf("发送失败\\n"); 
64.  \} 
65. 
66. //if(checkThrIsKill(thrReceive) == 1)\{ 
67. //printf("接受服务器数据的线程已被关闭，退出程序\\n");
68. //break;
69. //\}
70.  \} 
71. // 关闭套接字
72.  close(socketCon); 
73. **return** 0; 
74. \} 
75. 
76. **void** \*fun\_thrReceiveHandler(**void** \*socketCon)\{ 
77. **while**(1)\{ 
78. **char** buffer\[30\]; 
79. **int** \_socketCon = \*((**int** \*)socketCon); 
80. //int buffer\_length = recv(\_socketCon,buffer,30,0);
81. **int** buffer\_length = read(\_socketCon,buffer,30); 
82. **if**(buffer\_length == 0)\{ 
83.  printf("服务器端异常关闭\\n"); 
84.  exit(-1); 
85.  \}**else****if**(buffer\_length < 0)\{ 
86.  printf("接受客户端数据失败\\n"); 
87. **break**; 
88.  \} 
89.  buffer\[buffer\_length\] = '\\0'; 
90.  printf("服务器说：%s\\n",buffer); 
91.  \} 
92.  printf("退出接受服务器数据线程\\n"); 
93. **return** NULL; 
94. \} 
95. 
96. **int** checkThrIsKill(pthread\_t thr)\{ 
97. **int** res = 1; 
98. **int** res\_kill = pthread\_kill(thr,0); 
99. **if**(res\_kill == 0)\{ 
100.  res = 0; 
101.  \} 
102. **return** res; 
103. \}

顶

踩

*  上一篇[iOS第三方插件与App Demo地址总览][iOS_App Demo]
 *  下一篇[使用linux c 实现linux控制台 ls 命令][linux c _linux_ ls]
 *

[http_blog.csdn.net_returningprodigal_article_details_51916754]: http://blog.csdn.net/returningprodigal/article/details/51916754
[view plain]: http://blog.csdn.net/returningprodigal/article/details/51916754#
[iOS_App Demo]: http://blog.csdn.net/ReturningProdigal/article/details/51858555
[linux c _linux_ ls]: http://blog.csdn.net/ReturningProdigal/article/details/51967511