Select模型 详解

   讲一下套接字模式和套接字I/O模型的区别。先说明一下，只针对Winsock，如果你要骨头里挑鸡蛋把UNIX下的套接字概念来往这里套，那就不关我的事。

套接字模式：阻塞套接字和非阻塞套接字。或者叫同步套接字和异步套接字。
套接字模型：描述如何对套接字的I/O行为进行管理。
Winsock提供的I/O模型一共有五种：
select,WSAAsyncSelect,WSAEventSelect,Overlapped,Completion。今天先讲解select。
1：select模型（选择模型）
先看一下下面的这句代码：
int iResult = recv(s, buffer,1024);
这是用来接收数据的，在默认的阻塞模式下的套接字里，recv会阻塞在那里，直到套接字连接上有数据可读，把数据读到buffer里后recv函数才会返回，不然就会一直阻塞在那里。在单线程的程序里出现这种情况会导致主线程（单线程程序里只有一个默认的主线程）被阻塞,这样整个程序被锁死在这里，如果永远没数据发送过来，那么程序就会被永远锁死。这个问题可以用多线程解决，但是在有多个套接字连接的情况下，这不是一个好的选择，扩展性很差。Select模型就是为了解决这个问题而出现的。
再看代码：
int iResult = ioctlsocket(s, FIOBIO, (unsigned long *)&ul);
iResult = recv(s, buffer,1024);
这一次recv的调用不管套接字连接上有没有数据可以接收都会马上返回。原因就在于我们用ioctlsocket把套接字设置为非阻塞模式了。不过你跟踪一下就会发现，在没有数据的情况下，recv确实是马上返回了，但是也返回了一个错误：WSAEWOULDBLOCK，意思就是请求的操作没有成功完成。看到这里很多人可能会说，那么就重复调用recv并检查返回值，直到成功为止，但是这样做效率很成问题，开销太大。
感谢天才的微软工程师吧，他们给我们提供了好的解决办法。
先看看select函数
int select(
int nfds, 
fd_set FAR *readfds, 
fd_set FAR *writefds, 
fd_set FAR *exceptfds, 
const struct timeval FAR *timeout 
);
第一个参数不要管，会被系统忽略的。第二个参数是用来检查套接字可读性，也就说检查套接字上是否有数据可读，同样，第三个参数用来检查数据是否可以发出。最后一个是检查是否有带外数据可读取。
参数详细的意思请去看MSDN，这里限于篇幅不详细解释了。
最后一个参数是用来设置select等待多久的，是个结构：
struct timeval {
long tv_sec; // seconds 
long tv_usec; // and microseconds 
};
如果将这个结构设置为(0,0)，那么select函数会马上返回。
说了这么久，select的作用到底是什么？
他的作用就是：防止在在阻塞模式的套接字里被锁死，避免在非阻塞套接字里重复检查WSAEWOULDBLOCK错误。
他的工作流程如下：
1：用FD_ZERO宏来初始化我们感兴趣的fd_set，也就是select函数的第二三四个参数。
2：用FD_SET宏来将套接字句柄分配给相应的fd_set。
3：调用select函数。
4：用FD_ISSET对套接字句柄进行检查，如果我们所关注的那个套接字句柄仍然在开始分配的那个fd_set里，那么说明马上可以进行相应的IO操作。比如一个分配给select第一个参数的套接字句柄在select返回后仍然在select第一个参数的fd_set里，那么说明当前数据已经来了，马上可以读取成功而不会被阻塞。
下面给出一个简单的select模型的服务端套接字。
#include “iostream.h”
#include “winsock2.h”
#include “windows.h”
#define InternetAddr "127.0.0.1"
#define iPort 5055
#pragma comment(lib, "ws2_32.lib")
void main()
{
　　　　WSADATA wsa;
　　　　WSAStartup(MAKEWORD(2,2), &wsa);
　　　　
　　　　SOCKET fdServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
　　　　
　　　　struct sockaddr_in server;
　　　　server.sin_family = AF_INET;
　　　　server.sin_addr.s_addr = inet_addr(InternetAddr);
　　　　server.sin_port = htons(iPort);
　　　　
　　　　int ret = bind(fdServer, (sockaddr*)&server, sizeof(server));
　　　　ret = listen(fdServer, 4);
　　　　SOCKET AcceptSocket; 
　　　　fd_set fdread;
　　　　timeval tv;
　　　　int nSize; 
　　　　while(1)
　　　　{
　　　　　　　　
　　　　　　　　FD_ZERO(&fdread);//初始化fd_set
　　　　　　　　FD_SET(fdServer, &fdread);//分配套接字句柄到相应的fd_set
　　　　　　　　
　　　　　　　　
　　　　　　　　tv.tv_sec = 2;//这里我们打算让select等待两秒后返回，避免被锁死，也避免马上返回
　　　　　　　　tv.tv_usec = 0;
　　　　　　　　
　　　　　　　　select(0, &fdread, NULL, NULL, &tv);
　　　　　　　　
　　　　　　　　nSize = sizeof(server);
　　　　　　　　if (FD_ISSET(fdServer, &fdread))//如果套接字句柄还在fd_set里，说明客户端已经有connect的请求发过来了，马上可以accept成功
　　　　　　　　{
　　　　　　　　　　　　AcceptSocket = accept(fdServer,( sockaddr*) &server, &nSize);
　　　　　　　　　　　　break;
　　　　　　　　}
　　　　　　　　
　　　　　　　　else//还没有客户端的connect请求，我们可以去做别的事，避免像没有用select方式的阻塞套接字程序被锁死的情况，如果没用select,当程序运行到accept的时候客户端恰好没有connect请求，那么程序就会被锁死，做不了任何事情
　　　　　　　　{
　　　　　　　　　　　　//do something
　　　　　　　　　　　　::MessageBox(NULL, "waiting", "recv", MB_ICONINFORMATION);//别的事做完后，继续去检查是否有客户端连接请求
　　　　　　　　}
　　　　}
　　　　char buffer[128];
　　　　ZeroMemory(buffer, 128);
　　　　ret = recv(AcceptSocket,buffer,128,0);//这里同样可以用select，用法和上面一样
　　　　::MessageBox(NULL, buffer, "recv", MB_ICONINFORMATION);
　　　　closesocket(AcceptSocket);
　　　　WSACleanup();
　　　　
　　　　return;
}

 

 

使用select模型还会用到以下几个函数：

　　　FD_CLR(s,*set):从set中删除套接字s

         FD_ISSET(s,*set):检查s是否set集合的一名成员,

        FD_SET(s,*set)：将套接字s加入到set集

　　FD_ZERO(*set):清空set集合。

　　下面是一个基于select模型的例子，可管理多个客户端连接：

 

// Selecterver.cpp : Defines the entry point for the console .

//

#include "stdafx.h"

#include <winsock2.h>
#pragma comment(lib,"ws2_32.lib")
#define  PORT  1688

 

//Initilize the listen socket

bool InitAndListen(SOCKET &sListen)

{
    WSADATA wsaData;
    sockaddr_in local;
    WORD version=MAKEWORD(2,0);
    int ret=WSAStartup(version,&wsaData);
    if(ret != 0)
    {
        printf("WASStarup failed\n");
        return 0;
    }

    local.sin_family=AF_INET;

    local.sin_addr.s_addr=INADDR_ANY;
    local.sin_port=htons((u_short)PORT);

    //Initial socket
    sListen=socket(AF_INET,SOCK_STREAM,0);
    if(sListen == INVALID_SOCKET)
    {
        printf("Initial socket failed\n");
        return 0;
    }

    //Bind socket
    if(bind(sListen,(sockaddr*)&local,sizeof(local))!=0)
    {
        printf("Bind socket failed\n");
        return 0;
    }
    if(listen(sListen,10)!=0)  //Listen socket

　{

　　        printf("Listen socket failed");

                 return 0;
    }
    return 1;
}
int _tmain(int argc, _TCHAR* argv[])
{
    
    SOCKET sListen;
    if(InitAndListen(sListen) == 0)
    {
        return 0;
    }
    printf("Server wait for client connect...\n");
    fd_set fdSocket;
    FD_ZERO(&fdSocket);

    FD_SET(sListen,&fdSocket);    //Add the listen socket to FD_set : fdSocket

    while (true)

    {
        //assign the fdSocket to fdRead to select
        fd_set fdRead = fdSocket;
        int nRet = select(NULL,&fdRead,NULL,NULL,NULL);

        if (nRet <= 0)

        {
            printf("select failed\n");
            break;
        }
     
        for(int i=0;i<(int)fdSocket.fd_count;i++)
        { 
            //check whether the socket is set
            if(FD_ISSET(fdSocket.fd_array[i],&fdRead)) 
            {
                //New connect come
                if(fdSocket.fd_array[i] == sListen)
                {
                    sockaddr_in addrRemote;
                    int nAddrLen=sizeof(addrRemote);
                    SOCKET sNew=::accept(sListen,(sockaddr*)&addrRemote,&nAddrLen);
                    FD_SET(sNew,&fdSocket);//Put it to fdSocket sets
                    printf("Client %s connected\n",inet_ntoa(addrRemote.sin_addr));
                }
                else
                {
                    char buffer[1024];
                    memset(buffer,0,1024);
                    int nRecev = recv(fdSocket.fd_array[i],buffer,1024,0);

                    if (nRecev > 0)

                    {
                        printf("Received Client Msg:%s\n",buffer);

                        //echo back

                        send(fdSocket.fd_array[i],buffer,strlen(buffer),0);
                    }
                    else
                    {
                        //Close the socket and clear from the sets
                        closesocket(fdSocket.fd_array[i]);
                        FD_CLR(fdSocket.fd_array[i],&fdSocket);
                    }

                }

            }
        }
    }

    return 0;

}

 

 

 

 

 

Select模型的 单服务器多客户端示范代码

#include <stdio.h>

#include <iostream>
#include <winsock2.h>
using namespace std;
int main(){
    WORD version = MAKEWORD(2,2);
    WSADATA wsaData;
    SOCKET listenSocket;
    SOCKET acceptSocket;
    SOCKET clientSocket[FD_SETSIZE];
    int static index = 0;
    DWORD block = 1L;
    FD_SET ReadSet;
   //加载SOCKET库

    int f = WSAStartup(version,&wsaData);

    if (f != 0){
        cout<<"加载Winsock 库错误！ 错误号："<<WSAGetLastError()<<endl;
        return -1;

    }

    //创建监听SOCKET

    listenSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_IP);

    if (listenSocket == INVALID_SOCKET){
        WSACleanup();
        cout<<"创建监听SOCKET失败！ 错误号："<<WSAGetLastError()<<endl;
        return -1;

    }

    cout<<"监听SOCKET创建成功!\n"<<endl;

    //构造服务器地址

    SOCKADDR_IN serverIp;

                serverIp.sin_family = AF_INET;

                serverIp.sin_port = htons(8108);
                serverIp.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
    if (bind(listenSocket,(SOCKADDR*)&serverIp,sizeof(SOCKADDR)) == SOCKET_ERROR){
        cout<<"绑定服务器错误！ 错误号："<<WSAGetLastError()<<endl;
        return -1;

 

    }

    cout<<"绑定操作成功!\n"<<endl;

    if (listen(listenSocket,10) == SOCKET_ERROR){
        cout<<"进入监听模式错误！ 错误号："<<WSAGetLastError()<<endl;
        return -1;
    }
    cout<<"服务器已进入监听模式!\n"<<endl;

    if (ioctlsocket(listenSocket,FIONBIO,&block) == SOCKET_ERROR){

Cout<<"监听SOCKET设置为非阻塞模式错误！ 错误号："<<WSAGetLastError()<<endl;

        return -1;

    }

    cout<<"监听SOCKET已设置为非阻塞模式!\n\n\n"<<endl;

    //非阻塞模式接受客户端连接

    while(TRUE){

          cout<<"持续按非阻塞模式接受客户端连接请求!\n\n"<<endl;

          //将读SET 清0

          FD_ZERO(&ReadSet);

          //将已有客户端连接放到集合中!

          for (int i = 0; i < index; i  ){

        cout<<"将clientSocket["<<i<<"]放到ReadSet集合中!\n"<<endl;

               FD_SET(clientSocket[i],&ReadSet);

          }
        cout<<"监听SOCKET 放入 ReadSet集合中!\n\n"<<endl;

          FD_SET(listenSocket,&ReadSet);

          if (select(0,&ReadSet,NULL,NULL,NULL) == SOCKET_ERROR

              cout<<"select 监听SOCET错误! 错误号："<<WSAGetLastError()<<endl;

              system("pause");
              return -1;
          }

          cout<<"select 返回 说明已有客户端进行连接或有客户端数据读取或有客户端连接断开!\n\n\n"<<endl;

              if (FD_ISSET(listenSocket,&ReadSet)){

                  cout<<"当前ReadSet中存监听SOCKET!\n\n"<<endl;

                  acceptSocket = accept(listenSocket,NULL,NULL);
                  if (acceptSocket != INVALID_SOCKET){
             cout<<"客户端建立连接成功并保存到clientSocket["<<index<<"]中!\n\n"<<endl;
                      clientSocket[index] = acceptSocket;
                      index++   ;

                  }else {

                      cout<<"接收客户端连接错误! 错误号："<<WSAGetLastError()<<endl;

                   continue;

                  }

              }

              for (int j = 0; j < index; j  ){

                  if (FD_ISSET(clientSocket[j],&ReadSet)){

                      cout<<"当前ReadSet集合中有客户端SOCKET clientSocket["<<j<<"]可读数据!\n [message]"

                      char buffer[100]; memset(buffer,0,100);

                      if (recv(clientSocket[j],buffer,100,0) != SOCKET_ERROR){

                          cout<<buffer<<"[/messsage]\n"<<endl;

                      }else {

                          cout<<"客户端clientSocket["<<j<<"]出现错误! 错误号："<<WSAGetLastError()<<endl;

                          clientSocket[j] = NULL;

                          index –;

                          closesocket(clientSocket[j])
                          break;

                      }

 }            }

    }
  }

 

 

下面这段代码与上面所述的While(True)部分基本一致,但我本人感觉下面的方法更好.

while(true)

 {

  fd_set fdRead=fdSocket;

  if (::select(0,&fdSocket,NULL,NULL,NULL)==SOCKET_ERROR)
  {
   continue;
  }
  else
  { 
  TRACE("Wait somebody % i\n ",fdSocket.fd_count);
  for(int i=0;i<(int)fdSocket.fd_count;i++)
  { 

   if(FD_ISSET( fdSocket.fd_array[i], &fdSocket))

   {
    if(fdSocket.fd_array[i]==sListen)   
    { 
     CString strIP;
     sockaddr_in addrRemote;
     int nAddrLen=sizeof(addrRemote);
     SOCKET sNew=::accept(sListen,(sockaddr*)&addrRemote,&nAddrLen);
     FD_SET(sNew,&fdSocket);
     strIP.Format( "%s",inet_ntoa(addrRemote.sin_addr) );
     TRACE("NEW COME    %s\n",strIP);

    }//end if ==slisten

    else
    {
     int nRecev=::recv(fdSocket.fd_array[i],(char*)&recvPacket,sizeof(recvPacket),0);
     if (nRecev>0)
     {
      TRACE("recv msg %s\n",recvPacket);

     }else

     {
      ::closesocket(fdSocket.fd_array[i]);
      FD_CLR(fdSocket.fd_array[i],&fdSocket);
     }
    }
   }
  
  }
  }
 }
  return 0;