关于select单线程实现并发问题

wander__漫游世界

学习select实现单线程实现并发，在网上找到两种版本。
一种能够实现并发通信，一种只有一个客户段能够通信，十分不解。下面上源码，求帮忙分析一下。
第一种能实现并发：

1. /*
   
2.         Thu Sep 4,4:12PM，2014
   
3.         @wander
   
4.         email:czpwander@gmail.com       
   
5.         process: select socket server
   
6.         ps：单进程用select实现并发socket
   
7.         网上有几种不同的实现方式，本程序是通过主进程实现监听socket,然后用select实现连接socket
   
8.         select 程序中是每次有一个新连接，然后将连接描述符添加到select描述符中，也就是一个一个添加。
   
9. * */
   
10. 
    
11. #include <stdio.h>
    
12. #include <sys/socket.h>
    
13. #include <sys/types.h>
    
14. #include <string.h>
    
15. #include <netinet/in.h>
    
16. #include <unistd.h>
    
17. #include <stdlib.h>
    
18. #include <sys/select.h>
    
19. #include <sys/time.h>
    
20. 
    
21. #define LEN 1024
    
22. #define PORT 60606
    
23. #define BACKLOG 2
    
24. 
    
25. struct client{
    
26.         int fd;               
    
27.         struct sockaddr_in cli;
    
28. };
    
29. 
    
30. int main(void)
    
31. {
    
32.         struct client cl[FD_SETSIZE];//客户端数组
    
33.         int connfd;
    
34.         int i;
    
35.         int maxfd,sockfd;
    
36.         int maxi = -1;
    
37.         int nready;
    
38.         char buf[LEN];// 接收发送socket buf
    
39.         int listenfd = socket(AF_INET,SOCK_STREAM,0);//创建监听socket
    
40.         if(listenfd < 0){
    
41.                 perror("socket error\n");       
    
42.                 exit(-1);
    
43.         }
    
44. 
    
45.         int opt = SO_REUSEADDR;
    
46.         setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(int));//设置解绑地址
    
47.         struct sockaddr_in ser;
    
48.         socklen_t ser_len = sizeof(ser);
    
49.         ser.sin_family = AF_INET;
    
50.         ser.sin_port = htons(PORT);
    
51.         ser.sin_addr.s_addr = htonl(INADDR_ANY);
    
52.        
    
53.         int ret = bind(listenfd,(struct sockaddr*)&ser,ser_len);//bind
    
54.         if(ret < 0){
    
55.                 perror("bind error\n");
    
56.                 exit(-1);
    
57.         }
    
58.        
    
59.         ret = listen(listenfd,BACKLOG); //listen
    
60.         if(ret < 0){
    
61.                 perror("listen error\n");       
    
62.                 exit(-1);
    
63.         }
    
64.        
    
65.         //select
    
66.         maxfd = listenfd;
    
67.         for(i = 0;i < FD_SETSIZE;i ++){
    
68.                 cl[i].fd = -1;
    
69.         }
    
70.         fd_set read_fds;
    
71.         fd_set r_fds;
    
72.         FD_ZERO(&read_fds);
    
73.         FD_ZERO(&r_fds);
    
74.         FD_SET(listenfd,&read_fds);
    
75. 
    
76.         while(1){
    
77.                 memset(buf,0,LEN);       
    
78.                 struct sockaddr_in addr;
    
79.                 r_fds = read_fds;//将select描述符集，赋值给r_fds
    
80.                 socklen_t addr_len = sizeof(addr);
    
81.                 bzero(&addr,addr_len);
    
82. 
    
83.                 nready = select(maxfd+1,&r_fds,NULL,NULL,NULL);//  select
    
84.                 if(ret < 0){
    
85.                         perror("select error\n");
    
86.                         exit(-1);
    
87.                 }
    
88.                 if(FD_ISSET(listenfd,&r_fds)){// 判断是否有监听socket
    
89.                         printf("get new connect\n");
    
90.                         connfd = accept(listenfd,(struct sockaddr *)&addr,&addr_len);// accept socket
    
91.                         if(connfd < 0){
    
92.                                 perror("accept error\n");
    
93.                                 exit(-1);
    
94.                         }
    
95.                         printf("accept ok\n");       
    
96.                        
    
97.                         //将得到客户端地址 连接socketfd
    
98.                         for(i = 0;i < FD_SETSIZE;i ++){
    
99.                                 if(cl[i].fd < 0){
    
100.                                         cl[i].fd = connfd;
     
101.                                         cl[i].cli = addr;
     
102.                                         printf("got connect from %s\n",inet_ntoa(cl[i].cli.sin_addr));
     
103.                                         //printf("got connect from client %d\n",i);
     
104.                                         break;
     
105.                                 }
     
106.                         }
     
107.                         if(i == FD_SETSIZE){// 连接达到最大值
     
108.                                 printf("too many client connect\n");       
     
109.                                 continue;
     
110.                         }
     
111.                         FD_SET(connfd,&read_fds);//将连接sockefd添加到select描述符集中
     
112.                         if(connfd > maxfd)// 判断最大
     
113.                                 maxfd = connfd;
     
114.                         if(i > maxi){// 判断最大连接数
     
115.                                 maxi = i;
     
116.                                 printf("maxi:%d\n",maxi);
     
117.                         }
     
118.                         if(--nready <= 0)
     
119.                                 continue;//如果没有连接，就继续循环
     
120.                 }
     
121. 
     
122.                 for(i = 0;i <= maxi;i ++){// 判断是否有数据发送
     
123.                         if((sockfd = cl[i].fd) < 0)        //如果小于0，表示没有客户端连接
     
124.                                 continue;
     
125.                         if(FD_ISSET(sockfd,&r_fds)){
     
126.                                 printf("get the data\n");
     
127.                                 int r_size = recv(sockfd,buf,LEN,0);//接收数据
     
128.                                 if(r_size == 0){
     
129.                                         close(sockfd);
     
130.                                         printf("close the %d client\n",i);
     
131.                                 }
     
132.                                 else if(r_size > 0){
     
133.                                         printf("the client %d:",i);
     
134.                                         printf("%s \n",buf);
     
135.                                 }
     
136.                                 if(--nready <= 0)
     
137.                                         break;
     
138.                         }
     
139.                 }
     
140.         }
     
141.        
     
142.         close(connfd);
     
143.         close(listenfd);
     
144. }
     
145. 
     
146. 
     
147. 
     
148. 
     
149. 
     
150. 
     
151. 
     
152. 
     
153. 
     
154. 
     
155. 
     
156. 
     
157. 
     
158. 
     
159. 
     
160. 
     
161. 
     
162. 
     
163. 
     

复制代码

第二种，网上很多是第二种，但是能够建立连接，但是不能实现并发通信

1. /* 实现功能：通过select处理多个socket
   
2. * 监听一个端口,监听到有链接时,添加到select的w.
   
3. */
   
4. //#include "select.h"
   
5. #include <stdio.h>
   
6. #include <stdlib.h>
   
7. #include <sys/socket.h>
   
8. #include <sys/select.h>
   
9. #include <sys/time.h>
   
10. #include <netinet/in.h>
    
11. #include <string.h>
    
12. 
    
13. typedef struct _CLIENT{
    
14.     int fd;
    
15.     struct sockaddr_in addr; /* client's address information */
    
16. } CLIENT;
    
17. 
    
18. #define MYPORT 60606
    
19. 
    
20. //最多处理的connect
    
21. #define BACKLOG 2
    
22. 
    
23. //最多处理的connect
    
24. CLIENT client[BACKLOG];
    
25. 
    
26. //当前的连接数
    
27. int currentClient = 0;
    
28. 
    
29. //数据接受 buf
    
30. #define REVLEN 10
    
31. char recvBuf[REVLEN];
    
32. //显示当前的connection
    
33. void showClient();
    
34. 
    
35. int main()
    
36. {
    
37.     int i, ret, sinSize;
    
38.     int recvLen = 0;
    
39.     fd_set readfds, writefds;
    
40.     int sockListen, sockSvr, sockMax;
    
41.     struct timeval timeout;
    
42.     struct sockaddr_in server_addr;
    
43.     struct sockaddr_in client_addr;
    
44. 
    
45.         //将客户端端描述符置1
    
46.     for(i=0; i<BACKLOG; i++)
    
47.     {
    
48.         client[i].fd = -1;
    
49.     }
    
50. 
    
51.     //socket
    
52.     if((sockListen=socket(AF_INET, SOCK_STREAM, 0)) < 0)
    
53.     {
    
54.         printf("socket error\n");
    
55.         return -1;
    
56.     }
    
57. 
    
58.         int opt = SO_REUSEADDR;
    
59.         setsockopt(sockListen,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(int));
    
60.     bzero(&server_addr, sizeof(server_addr));
    
61.     server_addr.sin_family  =  AF_INET;
    
62.     server_addr.sin_port = htons(MYPORT);
    
63.     server_addr.sin_addr.s_addr  =  htonl(INADDR_ANY);
    
64. 
    
65.     //bind
    
66.     if(bind(sockListen, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0)
    
67.     {
    
68.         printf("bind error\n");
    
69.         return -1;
    
70.     }
    
71. 
    
72.     //listen
    
73.     if(listen(sockListen, 5) < 0)
    
74.     {
    
75.         printf("listen error\n");
    
76.         return -1;
    
77.     }
    
78. 
    
79.     for(i=0; i<BACKLOG; i++)
    
80.     {
    
81.         client[i].fd = -1;
    
82.     }
    
83. 
    
84.     //select
    
85.     while(1)
    
86.     {
    
87.         FD_ZERO(&readfds);
    
88.         FD_SET(sockListen, &readfds);
    
89.         sockMax = sockListen;
    
90.    
    
91.         //加入client
    
92.         for(i=0; i<BACKLOG; i++)
    
93.         {
    
94.             if(client[i].fd >0)
    
95.             {
    
96.                 FD_SET(client[i].fd, &readfds);
    
97.                 if(sockMax<client[i].fd)
    
98.                     sockMax = client[i].fd;
    
99.             }
    
100.         }
     
101.         
     
102.         timeout.tv_sec=10;               
     
103.         timeout.tv_usec=0;
     
104.         //select
     
105.         ret = select((int)sockMax+1, &readfds, NULL, NULL, &timeout);
     
106.         if(ret < 0)
     
107.         {
     
108.             printf("select error\n");
     
109.             break;
     
110.         }
     
111.         else if(ret == 0)
     
112.         {
     
113.             printf("timeout ...\n");
     
114.             continue;
     
115.         }
     
116.         //printf("test111\n");
     
117.    
     
118.         //读取数据
     
119.         for(i=0; i<BACKLOG; i++)
     
120.         {
     
121.             if(client[i].fd>0 && FD_ISSET(client[i].fd, &readfds))
     
122.             {
     
123.                 if(recvLen != REVLEN)
     
124.                 {
     
125.                     while(1)
     
126.                     {
     
127.                         //recv数据
     
128.                         ret = recv(client[i].fd, (char *)recvBuf+recvLen, REVLEN-recvLen, 0);
     
129.                         if(ret == 0)
     
130.                         {
     
131.                             client[i].fd = -1;
     
132.                             recvLen = 0;
     
133.                             break;
     
134.                         }
     
135.                         else if(ret < 0)
     
136.                         {
     
137.                             client[i].fd = -1;
     
138.                             recvLen = 0;
     
139.                             break;
     
140.                         }
     
141.                         //数据接受正常
     
142.                         recvLen = recvLen+ret;
     
143.                         if(recvLen<REVLEN)
     
144.                         {
     
145.                             continue;
     
146.                         }
     
147.                         else
     
148.                         {
     
149.                             //数据接受完毕
     
150.                             printf("%s, buf = %s\n", inet_ntoa(client[i].addr.sin_addr) , recvBuf);
     
151.                             //close(client[i].fd);
     
152.                             //client[i].fd = -1;
     
153.                             recvLen = 0;
     
154.                             break;
     
155.                         }
     
156.                     }
     
157.                 }
     
158.             }
     
159.         }
     
160.    
     
161.         //如果可读
     
162.         if(FD_ISSET(sockListen, &readfds))
     
163.         {
     
164.             printf("isset\n");
     
165.             sockSvr = accept(sockListen, NULL, NULL);//(struct sockaddr*)&client_addr
     
166.         
     
167.             if(sockSvr == -1)
     
168.             {
     
169.                 printf("accpet error\n");
     
170.             }
     
171.             else
     
172.             {
     
173.                 currentClient++;
     
174.             }
     
175.         
     
176.             for(i=0; i<BACKLOG; i++)
     
177.             {
     
178.                 if(client[i].fd < 0)
     
179.                 {
     
180.                     client[i].fd = sockSvr;
     
181.                     client[i].addr = client_addr;
     
182.                     printf("You got a connection from %s \n",inet_ntoa(client[i].addr.sin_addr) );
     
183.                     break;
     
184.                 }
     
185.             }
     
186.             //close(sockListen);
     
187.         }
     
188.     }
     
189. 
     
190.     printf("test\n");
     
191.     return 0;
     
192. }
     
193. 
     
194. //显示当前的connection
     
195. void showClient()
     
196. {
     
197.     int i;
     
198.     printf("client count = %d\n", currentClient);
     
199. 
     
200.     for(i=0; i<BACKLOG; i++)
     
201.     {
     
202.         printf("[%d] = %d", i, client[i].fd);
     
203.     }
     
204.     printf("\n");
     
205. }

复制代码

wander__漫游世界

不想贴子沉了。顶一下。还是希望大神们能够看看，相互交流一下。
楼主不想只是将代码敲一遍，然后就没有了。楼主想深入进去好好学习，期望摆脱菜鸟，以后也能为linux社区做贡献

wander__漫游世界

没人知道，天啊，竟然没人知道

guojinshuai

回复 3# wander__漫游世界


    楼主研究的怎么样了，我也在学习select呢，你说的第一个例子的源码就是<<unix网络编程>>上的代码吧，第二个例子的源码我也不明白，我也想知道为什么，楼主有答案了么？
   楼主给解释下吧

yulihua49

wander__漫游世界 发表于 2014-09-10 21:36
没人知道，天啊，竟然没人知道

第二个，为什么每次readfd都要accept呢？不是每个fd都要accept的。