linux 网络编程:使用两线程实现socket同时收发数据

转载：http://blog.csdn.net/li_wen01/article/details/52665505

工作中最近有使用到socket 向客户端同时发送和接收数据，因为是嵌入式linux设备，且要求只能同时一个客户端连接该端口。考虑到节省系统资源，只创建了两个线程分别实现服务端的收发数据。下面直接上代码，该代码为在PC机上程序，已作详细注释。

server.c

[objc] view plain copy

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. #include<string.h>  
4. #include<errno.h>  
5. #include<sys/types.h>  
6. #include<sys/socket.h>  
7. #include<netinet/in.h>  
8. #include<termios.h>  
9. #include<sys/types.h>     
10. #include<sys/stat.h>      
11. #include<fcntl.h>  
12. #include<unistd.h>  
13. #include<sys/ioctl.h>  
14. #include<signal.h>  
15.   
16. #define MAXLINE 256  
17. #define PORT    6666  
18. int listenfd;  
19. int connfd;  
20. pthread_t read_id, write_id;  
21.   
22. /* 
23. linux ctrl + C 会产生 SIGINT信号 
24. 接收到SIGINT 信号进入该函数 
25. */  
26. void stop(int signo)  
27. {  
28.     printf("stop\n");  
29.     close(connfd);    
30.     close(listenfd);  
31.      _exit(0);  
32. }  
33.   
34. /* 
35. 当客户端断开连接的时候， 
36. 在服务端socket send进程可以收到收到信号SIGPIPE， 
37. 收到SIGPIPE信号进入该函数结束创建的线程。 
38. */  
39. void signal_pipe(int signo)  
40. {  
41.     pthread_kill(read_id,SIGQUIT);//向read线程发送SIGQUIT  
42.     pthread_join(read_id,NULL);   //阻塞线程运行，直到read 线程退出。  
43.       
44.     close(connfd);                //关闭连接  
45.     printf("read pthread out \n");  
46.       
47.     pthread_exit(0);              //结束write 线程  
48. }  
49.   
50. /* 
51. read 线程接收到SIGQUIT信号， 
52. 执行线程退出操作 
53. */  
54. void pthread_out(int signo)  
55. {  
56.     pthread_exit(0);  
57. }  
58.   
59. /* 
60. read 线程执行函数 
61. */  
62. void* read_func(void* arg)  
63. {  
64.     char readbuff[MAXLINE];  
65.     int n = 0;  
66.     int fd;  
67.   
68.     fd = *(int*)arg;    /*main 主进程传递过来的连接文件描述符*/  
69.     memset(&readbuff,0,sizeof(readbuff));  
70.   
71.     signal(SIGQUIT,pthread_out); /* 注册SIGQUIT 信号*/   
72.     while(1)  
73.     {  
74.         n = recv(fd, readbuff, MAXLINE, 0);  /*recv 在这里是阻塞运行*/  
75.         if(n > 0)  
76.         {  
77.             printf("server recv data: %s \n",readbuff);  
78.         }  
79.     };  
80. }  
81. /* 
82. write 线程执行函数 
83. */  
84. void* write_func(void* arg)  
85. {  
86.     char writebuff[MAXLINE];  
87.     char* write = "I am server";  
88.     unsigned char i = 0;  
89.     int num = 0;  
90.     int fd;  
91.   
92.     fd = *(int*)arg;  
93.     memset(&writebuff,0,sizeof(writebuff));  
94.       
95.     signal(SIGPIPE,signal_pipe); /* 注册 SIGPIPE信号 */  
96.     while(1)  
97.     {  
98.         sleep(1);  
99.         send(fd,write,strlen(write)+1,0);/*向客户端发送数据*/  
100.     }  
101. }  
102.   
103. int main(int argc, char** argv)  
104. {  
105.     char buff[MAXLINE];  
106.     int num;  
107.     int addrlen;  
108.     struct sockaddr_in server_addr;  /*服务器地址结构*/  
109.     struct sockaddr_in client_addr;  /*客户端地址结构*/  
110.   
111.     if((listenfd = socket(AF_INET,SOCK_STREAM,0)) == -1)/*建立一个流式套接字*/  
112.     {  
113.         printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);  
114.         exit(0);  
115.     }  
116.       
117.     /*设置服务端地址*/  
118.     addrlen = sizeof(struct sockaddr_in);  
119.     memset(&server_addr, 0, addrlen);  
120.     server_addr.sin_family = AF_INET;    /*AF_INET表示 IPv4 Intern 协议*/  
121.     server_addr.sin_addr.s_addr = htonl(INADDR_ANY); /*INADDR_ANY 可以监听任意IP */  
122.     server_addr.sin_port = htons(PORT); /*设置端口*/  
123.       
124.     /*绑定地址结构到套接字描述符*/  
125.     if( bind(listenfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1)  
126.     {  
127.         printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);  
128.         exit(0);  
129.     }  
130.   
131.     /*设置监听队列，这里设置为1，表示只能同时处理一个客户端的连接*/  
132.     if( listen(listenfd, 1) == -1)  
133.     {  
134.         printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);  
135.         exit(0);  
136.     }  
137.       
138.     signal(SIGINT,stop); /*注册SIGINT 信号*/  
139.     while(1)  
140.     {     
141.         printf("wait client accpt \n");  
142.         if( (connfd = accept(listenfd, (struct sockaddr*)&client_addr, &addrlen)) == -1)/*接收客户端的连接，这里会阻塞，直到有客户端连接*/  
143.         {  
144.             printf("accept socket error: %s(errno: %d)",strerror(errno),errno);  
145.             continue;  
146.         }  
147.       
148.         if(pthread_create(&read_id,NULL,read_func,&connfd))/*创建 read 线程*/  
149.         {  
150.             printf("pthread_create read_func err\n");  
151.         }  
152.   
153.         if(pthread_create(&write_id,NULL,write_func,&connfd))/*创建 write 线程*/  
154.         {  
155.             printf("pthread_create write_func err\n");  
156.         }  
157.           
158.         pthread_join(write_id,NULL); /*阻塞，直到write进程退出后才进行新的客户端连接*/  
159.         printf("write pthread out \n");  
160.     }  
161. }  

    这里需要特别注意线程资源的回收，因为每次与客户端建立连接，服务端都会创建连个线程，因此我们需要在客户端断开连接时回收线程资源。在这里有两种方式来检测客户端是否已经断开连接。第一：上面server.c服务端使用的，当客户端断开连接时，send 所在的进程会收到一个SIGPIPE信号，服务端收到SIGPIPE信号就进行线程退出操作。第二：recv函数在对方断开连接它会返回参数0，根据该参数也可以知道客户端已经断开了连接。在下面你的client.c客户端测试程序使用的就是这种方式。

    这里还有一个问题，signal(SIGPIPE,signal_pipe)函数的注册，我本来是把它放置在主线程main函数中，然后在signal_pipe 同时回收read 和 write线程，结果read进程可以正常回收，write线程却回收失败，具体原因也不清楚，求高人指点。于是我就是用SIGQUIT信号，在write线程收到SIGPIPE信号时，通知read线程退出，直到其退出再退出write线程。这样就实现了系统资源的回收。

client客户端测试程序：

[objc] view plain copy

1. #include<stdio.h>         
2. #include<stdlib.h>  
3. #include<string.h>  
4. #include<errno.h>  
5. #include<sys/types.h>  
6. #include<sys/socket.h>  
7. #include<netinet/in.h>  
8. #include<termios.h>  
9. #include<sys/types.h>     
10. #include<sys/stat.h>      
11. #include<fcntl.h>  
12. #include<unistd.h>  
13. #include<sys/ioctl.h>  
14. #include<signal.h>  
15.   
16. #define MAXLINE 256  
17. #define PORT    6666  
18. int fd;  
19. /* 
20. linux ctrl + C 会产生 SIGINT信号 
21. 接收到SIGINT 信号进入该函数 
22. */  
23. void stop(int signo)  
24. {  
25.     printf("client stop\n");  
26.     close(fd);    
27.     _exit(0);  
28. }  
29.   
30. /*客户端处理函数*/  
31. void client_process(void)  
32. {  
33.     char readbuff[MAXLINE];  
34.     char writebuff[MAXLINE];  
35.     charchar * write = "I am client";  
36.     int num = 0;  
37.       
38.     while(1)  
39.     {  
40.         num = recv(fd,readbuff,MAXLINE,0);/*接收服务端的数据，recv在这里如果没有数据会阻塞*/  
41.         if(num > 0)  
42.         {  
43.             printf("client read data : %s \n",readbuff);  
44.             send(fd, write, strlen(write)+1, 0); /*接收到数据后再向服务端发送一个字符串*/  
45.         }  
46.         else if(num == 0)/*recv返回值为0 的时候表示服务端已经断开了连接*/  
47.         {  
48.             stop(1); /*执行退出操作*/  
49.         }  
50.     }  
51. }  
52.   
53. int main(int argc, char** argv)  
54. {  
55.     struct sockaddr_in server_addr;  
56.     struct sockaddr_in client_addr;  
57.     int ret;  
58.   
59.     fd = socket(AF_INET,SOCK_STREAM,0);/*建立流式套接字*/  
60.     if(fd < 0)  
61.     {  
62.         printf("clinet socket err \n");  
63.     }  
64.   
65.     /*设置服务端地址*/  
66.     memset(&server_addr,0,sizeof(server_addr));  
67.     server_addr.sin_family = AF_INET;               /*AF_INET表示 IPv4 Intern 协议*/  
68.     server_addr.sin_addr.s_addr = htonl(INADDR_ANY);/*INADDR_ANY 可以监听任意IP */  
69.     server_addr.sin_port = htons(PORT);             /*设置端口*/  
70.   
71.     inet_pton(AF_INET,argv[1],&server_addr.sin_addr);/*将用户输入的字符串类型的IP地址转为整型*/  
72.     connect(fd,(struct sockaddr*)&server_addr,sizeof(server_addr));/*连接服务器*/  
73.       
74.     signal(SIGINT,stop);    /*注册SIGINT信号*/  
75.     client_process();       /*进入处理函数*/  
76.       
77.     close(fd);/*关闭文件*/  
78.     return 0;  
79. }  

    在客户端是用recv 函数的返回值判断服务端是否断开连接而不是SIGPIPE信号，主要是在这程序中，我的实现是send函数在接收到服务端的数据才发送，所以如果在这里不会触发SIGPIPE信号。如果要实现客户端的独立收发，可以模仿服务端的实现方式，这里不再现实。

下面是测试执行情况：

[objc] view plain copy

1. root@ubuntu:/home/share/Socket# ./server   
2. wait client accpt   
3. server recv data: I am client   
4. server recv data: I am client   
5. server recv data: I am client   
6. server recv data: I am client   
7. server recv data: I am client   
8. server recv data: I am client   
9. server recv data: I am client   
10. server recv data: I am client   
11. read pthread out   
12. write pthread out   
13. wait client accpt   
14. server recv data: I am client   
15. server recv data: I am client   
16. server recv data: I am client   
17. read pthread out   
18. write pthread out   
19. wait client accpt  
20.   
21.   
22.   
23. root@ubuntu:/home/share/Socket# ./client 127.0.0.1  
24. client read data : I am server   
25. client read data : I am server   
26. client read data : I am server   
27. client read data : I am server   
28. client read data : I am server   
29. client read data : I am server   
30. client read data : I am server   
31. client read data : I am server   
32. ^Cclient stop  
33. root@ubuntu:/home/share/Socket# ./client 127.0.0.1  
34. client read data : I am server   
35. client read data : I am server   
36. client read data : I am server   
37. ^Cclient stop  
38. root@ubuntu:/home/share/Socket#   

    执行服务端从程序等待客户连接，执行客户端程序与服务端建立连接，服务端每秒向客户端发送字符串：I am server，客户端接收到数据后向服务端发送字符串： I am client 。在client端按下ctrl + c 结束客户端程序，服务端检测到客户端断开连接后，关闭文件描述符，回收创建的read 和write 线程。

[objc] view plain copy

1. root@ubuntu:/home/share/Socket# ./server   
2. wait client accpt   
3. server recv data: I am client   
4. server recv data: I am client   
5. server recv data: I am client   
6. server recv data: I am client   
7. server recv data: I am client   
8. ^Cstop  
9. root@ubuntu:/home/share/Socket#   
10.   
11. root@ubuntu:/home/share/Socket# ./client 127.0.0.1  
12. client read data : I am server   
13. client read data : I am server   
14. client read data : I am server   
15. client read data : I am server   
16. client read data : I am server   
17. client stop  
18. root@ubuntu:/home/share/Socket#  

   在服务端按下ctlc + c 服务端检测到SIGINT信号，关闭文件描述符结束程序，整个进程全部退出。客户端检测到服务端断开连接后，执行退出操作。

这里实现的是只有一个客户端同时连接时的处理方式，如果要处理多客户端同时连接，使用这种方式好像并不合适，可以使用多进程的方式处理。