当前位置： 代码迷 >> 综合 >> Winsock IO模型之select模型
  详细解决方案

Winsock IO模型之select模型

热度：39   发布时间：2023-12-09 01:02:42.0

    之所以称其为select模型是因为它主要是使用select函数来管理I/O的。这个模型的设计源于UNIX系统，目的是允许那些想要避免在套接字调用上阻塞的应用程序有能力管理多个套接字。

    int select(

         int nfds,                                                 // 忽略，仅是为了与Berkeley套接字兼容

         fd_set* readfds,                                  // 指向一个套接字集合，用来检查其可读性

         fd_set* writefds,                                 // 指向一个套接字集合，用来检查其可写性

         fd_set* exceptfds,                              // 指向一个套接字集合，用来检查错误

         const struct timeval* timeout           // 指定此函数等待的最长时间，如果为NULL，则最长时间为无限大

    );

 Select模型是最常见的I/O模型。

使用 int select( int nfds , fd_set FAR* readfds , fd_set FAR* writefds,fd_set FAR* exceptfds,const struct timeval FAR * timeout ) ;

函数来检查你要调用的Socket套接字是否已经有了需要处理的数据。

select包含三个Socket队列，分别代表： readfds ，检查可读性，writefds，检查可写性，exceptfds，例外数据。 timeout是select函数的返回时间。

例如，我们想要检查一个套接字是否有数据需要接收，我们可以把套接字句柄加入可读性检查队列中，然后调用select，如果，该套接字没有数据需要接收， select函数会把该套接字从可读性检查队列中删除掉，所以我们只要检查该套接字句柄是否还存在于可读性队列中，就可以知道到底有没有数据需要接收了。

timeout参数控制select完成的时间。若timeout参数为空指针，则select将一直阻塞到有一个描述字满足条件，否则的话，timeout指向一个timeval结构，其中指定了select调用在返回前等待多长时间。如果timeval为{0,0}，则select立即返回，这可用于探询所选套接口的状态，如果处于这种状态，则select调用可认为是非阻塞的，且一切适用于非阻塞调用的假设都适用于它，举例来说，阻塞钩子函数不应被调用，且WINDOWS套接口实现不应yield。

    函数调用成功，返回发生网络事件的所有套接字数量的总和。如果超过了时间限制返回0，失败则返回SOCKET_ERROR。

    typedef struct fd_set {

                  u_int fd_count;                                       // 下面数组的大小

                  SOCKET fd_array[FD_SETSIZE];       // 套接字句柄数组

     } fd_set;

  • FD_ZERO(*set)                            初始化set为空集合。集合在使用前应该总是清空
  • FD_CLR(s, *set)                          从set移除套接字s
  • FD_ISSET(s, *set)                       检查s是不是set的成员，如果是返回TRUE
  • FD_SET(s, *set)                           添加套接字到集合
typedef struct timeval{
long tv_sec;                        // 指示等待多少秒
long tv_usec;                      // 指示等待多少毫秒
} timeval;
下面给出使用select模式的例子，运行后在4567端口监听，接受客户端连接请求，打印出接收到的数据。（原来单线程也可以管理多个套接字）
[cpp]  view plain copy
  1. //  
  2. // initsock.h文件  
  3.   
  4. #include <winsock2.h>  
  5. #pragma comment(lib, "WS2_32")  // 链接到WS2_32.lib  
  6.   
  7. class CInitSock       
  8. {  
  9. public:  
  10.     CInitSock(BYTE minorVer = 2, BYTE majorVer = 2)  
  11.     {  
  12.         // 初始化WS2_32.dll  
  13.         WSADATA wsaData;  
  14.         WORD sockVersion = MAKEWORD(minorVer, majorVer);  
  15.         if(::WSAStartup(sockVersion, &wsaData) != 0)  
  16.         {  
  17.             exit(0);  
  18.         }  
  19.     }  
  20.     ~CInitSock()  
  21.     {     
  22.         ::WSACleanup();   
  23.     }  
  24. };  
  25.   
  26.   
  27. //  
  28. // select.cpp文件  
  29.   
  30.   
  31. #include "../common/initsock.h"  
  32. #include <stdio.h>  
  33.   
  34. CInitSock theSock;      // 初始化Winsock库  
  35. int main()  
  36. {  
  37.     USHORT nPort = 4567;    // 此服务器监听的端口号  
  38.   
  39.     // 创建监听套节字  
  40.     SOCKET sListen = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);     
  41.     sockaddr_in sin;  
  42.     sin.sin_family = AF_INET;  
  43.     sin.sin_port = htons(nPort);  
  44.     sin.sin_addr.S_un.S_addr = INADDR_ANY;  
  45.     // 绑定套节字到本地机器  
  46.     if(::bind(sListen, (sockaddr*)&sin, sizeof(sin)) == SOCKET_ERROR)  
  47.     {  
  48.         printf(" Failed bind() \n");  
  49.         return -1;  
  50.     }  
  51.     // 进入监听模式  
  52.     ::listen(sListen, 5);  
  53.   
  54.         // select模型处理过程  
  55.     // 1）初始化一个套节字集合fdSocket，添加监听套节字句柄到这个集合  
  56.     fd_set fdSocket;        // 所有可用套节字集合  
  57.     FD_ZERO(&fdSocket);  
  58.     FD_SET(sListen, &fdSocket);  
  59.     while(TRUE)  
  60.     {  
  61.         // 2）将fdSocket集合的一个拷贝fdRead传递给select函数，  
  62.         // 当有事件发生时，select函数移除fdRead集合中没有未决I/O操作的套节字句柄，然后返回。  
  63.         fd_set fdRead = fdSocket;  
  64.         int nRet = ::select(0, &fdRead, NULL, NULL, NULL);  
  65.         if(nRet > 0)  
  66.         {  
  67.             // 3）通过将原来fdSocket集合与select处理过的fdRead集合比较，  
  68.             // 确定都有哪些套节字有未决I/O，并进一步处理这些I/O。  
  69.             for(int i=0; i<(int)fdSocket.fd_count; i++)  
  70.             {  
  71.                 if(FD_ISSET(fdSocket.fd_array[i], &fdRead))  
  72.                 {  
  73.                     if(fdSocket.fd_array[i] == sListen)     // （1）监听套节字接收到新连接  
  74.                     {  
  75.                         if(fdSocket.fd_count < FD_SETSIZE)  
  76.                         {  
  77.                             sockaddr_in addrRemote;  
  78.                             int nAddrLen = sizeof(addrRemote);  
  79.                             SOCKET sNew = ::accept(sListen, (SOCKADDR*)&addrRemote, &nAddrLen);  
  80.                             FD_SET(sNew, &fdSocket);  
  81.                             printf("接收到连接（%s）\n", ::inet_ntoa(addrRemote.sin_addr));  
  82.                         }  
  83.                         else  
  84.                         {  
  85.                             printf(" Too much connections! \n");  
  86.                             continue;  
  87.                         }  
  88.                     }  
  89.                     else  
  90.                     {  
  91.                         char szText[256];  
  92.                         int nRecv = ::recv(fdSocket.fd_array[i], szText, strlen(szText), 0);  
  93.                         if(nRecv > 0)                        // （2）可读  
  94.                         {  
  95.                             szText[nRecv] = '\0';  
  96.                             printf("接收到数据：%s \n", szText);  
  97.                         }  
  98.                         else                                // （3）连接关闭、重启或者中断  
  99.                         {  
  100.                             ::closesocket(fdSocket.fd_array[i]);  
  101.                             FD_CLR(fdSocket.fd_array[i], &fdSocket);  
  102.                         }  
  103.                     }  
  104.                 }  
  105.             }  
  106.         }  
  107.         else  
  108.         {  
  109.             printf(" Failed select() \n");  
  110.             break;  
  111.         }  
  112.     }  
  113.     return 0;  
  114. }  
大体流程：
//创建服务器套接字
socket
//绑定本地地址
bind
//进入监听模式
listen
//select模式
//构造fd_set集合
fd_set fdSocket;   
//清空fd_set集合并将服务器套接字加入
FD_ZERO(&fdSocket);  
FD_SET(sListen, &fdSocket);  
//循环
//复制一份fd_set集合并放入select中检测
fd_set fdRead = fdSocket;  
int nRet = ::select(0, &fdRead, NULL, NULL, NULL);  
//根据select结果进行相应处理（accept read ）


总结：通过select模式，实现了监听socket的accept和客户端的read之间，以及各个客户端之间的read，可以不用一直阻塞在那，而是在有相应事件的时候再进行阻塞处理，把accept和read两个长阻塞转化为select一个长阻塞。

    使用select的好处是程序能够在单个线程内同时处理多个套接字连接，这避免了阻塞模式下的线程膨胀问题。但是，添加到fd_set结构的套接字数量是有限制的，默认情况下，最大值是FD_SETSIZE，它在winsock2.h文件中定义为64。为了增加套接字数量，应用程序可以将FD_SETSIZE定义为更大的值（这个定义必须在包含winsock2.h之前出现）。不过，自定义的值也不能超过Winsock下层提供者的限制（通常是1024）。
另外，FD_SETSIZE的值太大的话，服务器性能就会受到影响。例如有1000个套接字，那么在调用select之前就不得不设置这1000个套接字，select返回之后，又必须检查这1000个套接字。
  相关解决方案

代码迷 - 您身边的软件异常，代码异常，编程异常助手（发现，解决，分享）
Copyright © 2009-2013 DAIMAMI.COM. All rights reserved.