套接字通信中的IO的select模式

关于IO的select模式。先说下阻塞和非阻塞模式。

阻塞模式下，如果直接调用recv从指定的SOCKET读取数据，如果还没有接受到来自连接的套接字的数据，函数recv会一直阻塞在那里，直到有数据可以读出为止，才返回。

而非阻塞模式下，不管有没有数据可读，recv函数会立即返回，如果此时没有数据到达，该函数调用必然失败，返回值为WSAEWOULDBLOCK，表明当前状态是非阻塞模式的调用，且没有数据到达。这时，通常的做法是，创建一个独立的线程调用recv判断返回值(如果是WSAEWOULDBLOCK)进行循环调用recv直到有数据到达为止，这样虽然可以，但是开销大，效率太低。

多线程是解决方法之一，每次都创建一个线程来处理。但用select模式来处理非阻塞模式更合适。它利用select函数，实现对I/O的管理。利用select函数，判断套接字上是否存在数据，或者能否向一个套接字写入数据。这样可以防止应用程序在套接字处于锁定模式中时，在一次I/O绑定调用（如send或recv）过程中，被迫进入“锁定”状态。

 看了这篇http://blog.csdn.net/dapengbusi/article/details/50690690

但它没有进行错误异常处理。包括客户端断开连接，服务端会直接崩溃，也没处理。自己重写了下select模式的简单代码：

 

//服务端 select_server.cpp

#include "stdafx.h"
#include<winSock2.h>
#include<stdio.h>
#include<iostream>
#pragma comment(lib,"ws2_32.lib")
using namespace std;
int socketcount = 0;
const int SOCKET_MAX_COUNTS=50;
SOCKET Sockets[SOCKET_MAX_COUNTS];
void addsocket(SOCKET s)
{
         if(socketcount<0|| socketcount>=SOCKET_MAX_COUNTS)
      return ;
         Sockets[socketcount++]=s;
}

int _tmain(int argc, _TCHAR* argv[])
{
         cout<<"server  is starting ..."<<endl;
         WSAData wsadata;
          //加载当前协议  
   if(WSAStartup(MAKEWORD(2,2),&wsadata)!=0)  
   {  
       printf("无法加载套接字协议栈\n");   
   }  
   //设置侦听套接字  
   SOCKET listenSocket = socket(AF_INET,SOCK_STREAM,0);
   if(listenSocket==INVALID_SOCKET)  
   {  
       cout<<"套接字初始化出现错误！错误号："<<WSAGetLastError()<<endl;     
   }        
         //初始化套接字
         addsocket(listenSocket);
         SOCKADDR_IN sockaddr;
         sockaddr.sin_family= AF_INET;
         sockaddr.sin_addr.s_addr=htonl(INADDR_ANY);
         sockaddr.sin_port= htons(8888);
         if(bind(listenSocket,(LPSOCKADDR)&sockaddr,sizeof(sockaddr))==SOCKET_ERROR)
         {
                   cout<<"绑定错误："<<WSAGetLastError()<<endl;         
         }

         if(listen(listenSocket,5)==SOCKET_ERROR)
         {
                  cout<<"监听错误："<<WSAGetLastError()<<endl;
         }
         
         //设置为非阻塞模式
         unsigned long nonBlock = 1;
         ioctlsocket(listenSocket,FIONBIO,&nonBlock);
         while(1)
         {
             //读FD集，清零初始化
             FD_SET read_set;
             FD_ZERO(&read_set);

             //把socket放入读集合中，让内核检测这些socket是否读就绪
             for(inti=0;i<socketcount;i++)
             FD_SET(Sockets[i],&read_set);
          
            //Select函数去检查读集中是否有socket读就绪
             inttotal = select(0,&read_set,nullptr,nullptr,nullptr)
             for(int i=0;i<socketcount;i++)
                   {
                          char szTemp[20]= {0};
                          sprintf_s(szTemp,"%d",i);
                          if(Sockets[i]==listenSocket)
                           {
                              cout<<"Sockets["<<i<<"]="<<Sockets[i]<<endl;
                               if(FD_ISSET(listenSocket,&read_set))
                               {
                                    cout<<"listenSocket isready!"<<endl;
                                    
                                    //接受来自客户端的连接请求
                                     sockaddr_in addrClient ;
                                     intlen = sizeof(SOCKADDR);
                                     SOCKET dataSocket=0;
                                     dataSocket= accept(listenSocket,(LPSOCKADDR)&addrClient,&len);
                                     if(dataSocket== INVALID_SOCKET)
                                     {
                                      cout<<"errorconnect"<<endl;
                                      break;
                                      }
                                      else             
                                       cout<<"socket"<<dataSocket<<" is connected!"<<endl;
 
                                     //设置非阻塞
                                    nonBlock= 1;
                                   ioctlsocket(dataSocket,FIONBIO,&nonBlock);
                                   addsocket(dataSocket);
                               }
                             continue;
                            }
 
               //如果通信的socket处于就绪状态
               if(FD_ISSET(Sockets[i],&read_set))
               {
                 cout<<"receieveSockets["<<i<<"]=="<<Sockets[i]<<endl;
                 if(recv(Sockets[i],szTemp,sizeof(szTemp)-1,0)!=SOCKET_ERROR)   //意外断开连接包括断网，客户端断开的处理
                 {
                    cout<<"Sockets["<<i<<"]is "<<Sockets[i]<<" saying ："<<szTemp<<endl;                          
                 }

                 else
                 {
                cout<<"Sockets["<<i<<"] isdisconnected!"<<endl; 
                FD_CLR(Sockets[i],&read_set);  //将断开的套接字从FD集中删除
                Sockets[i] = 0;
                socketcount--;     //删除断开的连接套接字
                    }
                }
           } 

         }
         return0;
}

 

 

//客户端 select_client.cpp
#include "stdafx.h"
#include<winSock2.h>
#include<iostream>
#pragma comment(lib,"ws2_32.lib")
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
         WSAData wsadata;
          //加载当前协议  
   if(WSAStartup(MAKEWORD(2,2),&wsadata)!=0)  
   {  
       printf("无法加载套接字协议栈\n");  
   }  
        SOCKET socketClient = socket(AF_INET,SOCK_STREAM,0);
   if(socketClient==INVALID_SOCKET)  
   {  
       printf("套接字初始化出现错误；错误号：%d\n",WSAGetLastError());  
   }  
     sockaddr_in sockaddr;
     sockaddr.sin_family= AF_INET;
     sockaddr.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
     sockaddr.sin_port= htons(8888); 
         if(connect(socketClient,(LPSOCKADDR)&sockaddr,sizeof(sockaddr))==0)
                   cout<<"连接服务器成功！"<<endl;
         else
         {
                   cout<<"连接服务器失败!"<<endl;
                   return-1;
         }
         while(1)
         {
                   char szsendbuf[100] = {0};
                   cout<<"isay:"<<endl;
                   cin>>szsendbuf;
                   if(strcmp(szsendbuf,"0")==0)  //输入0，关闭套接字
                            break;
                  send(socketClient,szsendbuf,strlen(szsendbuf)+1,0);
         }
         closesocket(socketClient);
         WSACleanup();
         return0;

}

运行如下：