网络服务器 select同时处理读写的疑问

imjacob

我现在实现个网络server有这样的需求,  一般情况下是 从客户端读数据的,  但是有时候需要往客户端主动去写数据,我想到了用select.

select的原型是 ( nfds, readfds,   writefds, errorfds, time)是这样的,  看这个是能够同时处理 read和write的同时访问,
但我无论是 书上 和网络上,查了一下,select的一般例子都是 用于多客户端读的情况, 基本代码如下:

1. 
   
2.     server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
   
3. 
   
4.     server_address.sin_family = AF_INET;
   
5.     server_address.sin_addr.s_addr = htonl(INADDR_ANY);
   
6.     server_address.sin_port = htons(9734);
   
7.     server_len = sizeof(server_address);
   
8. 
   
9.     bind(server_sockfd, (struct sockaddr *)&server_address, server_len);
   
10. 
    
11. /*  Create a connection queue and initialize readfds to handle input from server_sockfd.  */
    
12. 
    
13.     listen(server_sockfd, 5);
    
14. 
    
15.     FD_ZERO(&readfds);
    
16.     FD_SET(server_sockfd, &readfds);
    
17. 
    
18. /*  Now wait for clients and requests.
    
19.     Since we have passed a null pointer as the timeout parameter, no timeout will occur.
    
20.     The program will exit and report an error if select returns a value of less than 1.  */
    
21. 
    
22.     while(1) {
    
23.         char ch;
    
24.         int fd;
    
25.         int nread;
    
26. 
    
27.         testfds = readfds;
    
28. 
    
29.         printf("server waiting\n");
    
30.         result = select(FD_SETSIZE, &testfds, (fd_set *)0,
    
31.             (fd_set *)0, (struct timeval *) 0);
    
32. 
    
33.         if(result < 1) {
    
34.             perror("server5");
    
35.             exit(1);
    
36.         }
    
37. 
    
38. /*  Once we know we've got activity,
    
39.     we find which descriptor it's on by checking each in turn using FD_ISSET.  */
    
40. 
    
41.         for(fd = 0; fd < FD_SETSIZE; fd++) {
    
42.             if(FD_ISSET(fd,&testfds)) {
    
43. 
    
44. /*  If the activity is on server_sockfd, it must be a request for a new connection
    
45.     and we add the associated client_sockfd to the descriptor set.  */
    
46. 
    
47.                 if(fd == server_sockfd) {
    
48.                     client_len = sizeof(client_address);
    
49.                     client_sockfd = accept(server_sockfd,
    
50.                         (struct sockaddr *)&client_address, &client_len);
    
51.                     FD_SET(client_sockfd, &readfds);
    
52.                     printf("adding client on fd %d\n", client_sockfd);
    
53.                 }
    
54. 
    
55. /*  If it isn't the server, it must be client activity.
    
56.     If close is received, the client has gone away and we remove it from the descriptor set.
    
57.     Otherwise, we 'serve' the client as in the previous examples.  */
    
58. 
    
59.                 else {
    
60.                     ioctl(fd, FIONREAD, &nread);
    
61. 
    
62.                     if(nread == 0) {
    
63.                         close(fd);
    
64.                         FD_CLR(fd, &readfds);
    
65.                         printf("removing client on fd %d\n", fd);
    
66.                     }
    
67. 
    
68.                     else {
    
69.                         read(fd, &ch, 1);
    
70.                         sleep(5);
    
71.                         printf("serving client on fd %d\n", fd);
    
72.                         ch++;
    
73.                         write(fd, &ch, 1);
    
74.                     }
    
75.                 }
    
76.             }
    
77.         }
    
78.     }

复制代码

那想请教如何用select实现 读写都可以呢?

tcm123

因为读不知道什么时候有数据来，所以才用SELECT, 要写直接写就行了

imjacob

tcm123 发表于 2016-1-9 17:32
因为读不知道什么时候有数据来，所以才用SELECT, 要写直接写就行了

在同一个线程里吗？ 譬如我的例子，写在哪里

imjacob

又仔细查了些资料，加上自己的思考，是否可以这样，基本原理是 每次读写 读写之前用select判断是否可读或者可写，代码大致如下

1. 
   
2.     //这里区分是需要读还是写
   
3. BOOL NET::SelectFun(SOCKET sock,BOOL ret) //ret为true表示要读取数据，ret为false表示要发送数据  
   
4. {
   
5.     if (ret) //ret只是用来区分读写  
   
6.     {  
   
7.        num=select(0,&fd,NULL,NULL,&tval);  
   
8.     }  
   
9.     else  
   
10.     {  
    
11.         num=select(0,NULL,&fd,NULL,&tval);  
    
12.     }
    
13. }
    
14. 
    
15. //接收的线程里
    
16. UINT NET::ThreadReceive()
    
17. {
    
18.       while (1)  
    
19.     {  
    
20.         if(NET->SelectFun(NET->m_sock,TRUE)) // 判断，如果select判断为真则读取数据  
    
21.         {  
    
22.   
    
23.             res=recv ()
    
24.   
    
25.         }
    
26. }
    
27. 
    
28. 
    
29. //发送的线程里
    
30. UINT NET::ThreadSend()
    
31. {
    
32.       while (1)  
    
33.     {  
    
34.         if(NET->SelectFun(pDlg->m_sock,TRUE)) // 判断，如果select判断为真则读取数据  
    
35.         {  
    
36.   
    
37.             res=send()         
    
38.   
    
39.         }
    
40. }
    
41.   

复制代码

虽然感觉可以，但是需要用两个线程，能不能用一个呢？两个的情况下，这种所谓的IO多路复用方式没体现出优势啊，因为我原始的用socket分别在两个socket读和写也是可以的啊。恳请各位指教。

当然在另外一个帖子里，有朋友说那些libuv之类的库，我看了下确实能够比较好的解决这个问题，但担心效率速度。
因为是在单片机里，那些库要占用额外的资源的，所以不太敢用。

imjacob

更新一下，想到的另外一个方式是：
一个线程专门写， 不能阻塞
另一个线程用select来查询是否可读。