套接字I/O模型之WSAEventSelect

最新推荐文章于 2018-06-23 12:53:31 发布

yuntongsf

最新推荐文章于 2018-06-23 12:53:31 发布

阅读量990

点赞数

文章标签： socket events 网络 buffer null 服务器

套接字模式和套接字I/O模型的区别。

套接字模式：阻塞套接字和非阻塞套接字。或者叫同步套接字和异步套接字。

套接字模型：描述如何对套接字的I/O行为进行管理。

Winsock提供的I/O模型一共有五种：

select,WSAAsyncSelect,WSAEventSelect,Overlapped,Completion。

1：select模型（选择模型）

先看一下下面的这句代码：

intiResult=recv(s,buffer,1024);

这是用来接收数据的，在默认的阻塞模式下的套接字里，recv会阻塞在那里，直到套接字连接上有数据可读，把数据读到buffer里后recv函数才会返回，不然就会一直阻塞在那里。在单线程的程序里出现这种情况会导致主线程（单线程程序里只有一个默认的主线程）被阻塞,这样整个程序被锁死在这里，如果永远没数据发送过来，那么程序就会被永远锁死。这个问题可以用多线程解决，但是在有多个套接字连接的情况下，这不是一个好的选择，扩展性很差。Select模型就是为了解决这个问题而出现的。

再看代码：

intiResult=ioctlsocket(s,FIOBIO,(unsignedlong*)&ul);

iResult=recv(s,buffer,1024);

这一次recv的调用不管套接字连接上有没有数据可以接收都会马上返回。原因就在于我们用ioctlsocket把套接字设置为非阻塞模式了。不过你跟踪一下就会发现，在没有数据的情况下，recv确实是马上返回了，但是也返回了一个错误：WSAEWOULDBLOCK，意思就是请求的操作没有成功完成。看到这里很多人可能会说，那么就重复调用recv并检查返回值，直到成功为止，但是这样做效率很成问题，开销太大。

感谢天才的微软工程师吧，他们给我们提供了好的解决办法。

先看看select函数

intselect(

intnfds,

fd_setFAR*readfds,

fd_setFAR*writefds,

fd_setFAR*exceptfds,

conststructtimevalFAR*timeout

);

第一个参数不要管，会被系统忽略的。第二个参数是用来检查套接字可读性，也就说检查套接字上是否有数据可读，同样，第三个参数用来检查数据是否可以发出。最后一个是检查是否有带外数据可读取。

参数详细的意思请去看MSDN，这里限于篇幅不详细解释了。

最后一个参数是用来设置select等待多久的，是个结构：

structtimeval{

longtv_sec;//seconds

longtv_usec;//andmicroseconds

};

如果将这个结构设置为(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”

#defineInternetAddr"127.0.0.1"

#defineiPort5055

#pragmacomment(lib,"ws2_32.lib")

voidmain()

{

　　　　WSADATAwsa;

　　　　WSAStartup(MAKEWORD(2,2),&wsa);

　　　　SOCKETfdServer=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

　　　　structsockaddr_inserver;

　　　　server.sin_family=AF_INET;

　　　　server.sin_addr.s_addr=inet_addr(InternetAddr);

　　　　server.sin_port=htons(iPort);

　　　　intret=bind(fdServer,(sockaddr*)&server,sizeof(server));

　　　　ret=listen(fdServer,4);

　　　　SOCKETAcceptSocket;

　　　　fd_setfdread;

　　　　timevaltv;

　　　　intnSize;

　　　　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请求，那么程序就会被锁死，做不了任何事情

　　　　　　　　{

　　　　　　　　　　　　//dosomething

　　　　　　　　　　　　::MessageBox(NULL,"waiting...","recv",MB_ICONINFORMATION);//别的事做完后，继续去检查是否有客户端连接请求

　　　　　　　　}

　　　　charbuffer[128];

　　　　ZeroMemory(buffer,128);

　　　　ret=recv(AcceptSocket,buffer,128,0);//这里同样可以用select，用法和上面一样

　　　　::MessageBox(NULL,buffer,"recv",MB_ICONINFORMATION);

　　　　closesocket(AcceptSocket);

　　　　WSACleanup();

　　　　return;

}

摘自：http://laiba.tianya.cn/laiba/CommMsgs?cmm=14622&tid=2676954505305744775

今天我又学习了一种新的套接字I/O模型------WSAEventSelect，他与WSAAsyncSelect一样也是一种异步事件通知模型，不同的是WSAAsyncSelect是与窗口句柄关联在一起的，必须要要窗口才行，而WSAEventSelect是与事件对象关联的。这个模型的基本思路是为感兴趣的一组网络事件创建一个事件对象，再调用WSAEventSelect函数将网络事件和事件对象关联起来。当网络事件发生时，winsock使响应的事件对象受信，在事件对象上等待的函数就会立即返回。之后调用WSAEnumNetworkEvents函数便可获得到底发生了什么网络事件（FD_READ/FD_ACCEPT/FD_CLOSE等等）。

用到的函数有：

WSACreateEvent 、WSAEventSelect、WSAWaitForMultipleEvents、WSAEnumNetworkEvents

等，这里只详细介绍下WSAWaitForMultipleEvents函数

关联了事件对象后就可以用WSAWaitForMultipleEvents函数在一个或多个事件对象上等待了，当所等待的事件对象受信或者指定的时间过去了，此函数返回。

WSAWaitForMultipleEvents(

DWORD cEVents; //指定下面lpEvents所指的数组中事件对象句柄的个数

const WSAEVENT* lpEvents； //指向一个事件对象句柄的数组

BOOL fWaitAll； //指定是否等待所有的事件对象都变成受信状态（为TRUE：是；FALSE:否)

DWORD dwTimeout; //指定要等待的时间，可以为WSA_INFINITE

BOOL fAlertable; //设为FALSE

);

函数最多可以支持WSA_MAXIMUM_WAIT_EVENTS个对象,他的大小是64.该函数会等待网络事件的发生,如果过了指定了时间(dwTimeOut)则返回WSA_WAIT_TIMEOUT,如果在规定的时间内有事件发生,则返回该事件对象的索引(注意:在程序中要想得到发生的事件的真正索引需得用返回值减去WSA_WAIT_EVENT_0),调用失败返回WSA_WAIT_FAILED.如果将参数fWaitAll设置成false如果有多个网络事件发生该函数也只返回一个事件对象索引,并且该事件是在事件句柄数组中最前面的一个.解决方法是循环调用该函数处理后面的受信事件.
该函数的第一个参数是后面事件对象句柄数组的大小,第二个是个事件对象句柄数组,最后一个设置成false即可.
一旦事件对象受信那么找到与之对应的套接字,然后调用 int WSAEnumNetWorkEvent(SOCKET s, WSAEVENT hEventHandle, LPWSANETWORKEVENTS *LPWSANETWORKEVENTS)可以查看发生的网络事件,第一个参数和相应的网络事件标识做与运算就可.第二参数是返回的错误信息。

下面给分别给出用WSAEventSelect模型写出的TCP/UDP服务器例子.

TCP例子：

view plaincopy to clipboardprint?
// 事件句柄和套节字句柄表
    WSAEVENT    eventArray[WSA_MAXIMUM_WAIT_EVENTS];
    SOCKET      sockArray[WSA_MAXIMUM_WAIT_EVENTS];
    int nEventTotal = 0;

    USHORT nPort = 6000;    // 此服务器监听的端口号

    // 创建监听套节字
    SOCKET sListen = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(nPort);
    sin.sin_addr.S_un.S_addr = INADDR_ANY;
    if(::bind(sListen, (sockaddr*)&sin, sizeof(sin)) == SOCKET_ERROR)
    {
        printf(" Failed bind() /n");
        return -1;
    }
    ::listen(sListen, 5);

    // 创建事件对象，并关联到新的套节字
    WSAEVENT event = ::WSACreateEvent();
    ::WSAEventSelect(sListen, event, FD_ACCEPT|FD_CLOSE);
    // 添加到表中
    eventArray[nEventTotal] = event;
    sockArray[nEventTotal] = sListen;
    nEventTotal++;

    // 处理网络事件
    while(TRUE)
    {
        // 在所有事件对象上等待
        int nIndex = ::WSAWaitForMultipleEvents(nEventTotal, eventArray, FALSE, WSA_INFINITE, FALSE);
        // 对每个事件调用WSAWaitForMultipleEvents函数，以便确定它的状态
        nIndex = nIndex - WSA_WAIT_EVENT_0;//发生的事件对象的索引，一般是句柄数组中最前面的那一个，然后再用循环依次处理后面的事件对象
        for(int i=nIndex; i<nEventTotal; i++)
        {
            int ret;
            ret = ::WSAWaitForMultipleEvents(1, &eventArray[i], TRUE, 1000, FALSE);
            if(ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
            {
                continue;
            }
            else
            {
                // 获取到来的通知消息，WSAEnumNetworkEvents函数会自动重置受信事件
                WSANETWORKEVENTS event;
                ::WSAEnumNetworkEvents(sockArray[i], eventArray[i], &event);
                if(event.lNetworkEvents & FD_ACCEPT)                // 处理FD_ACCEPT通知消息
                {
                    if(event.iErrorCode[FD_ACCEPT_BIT] == 0)
                    {
                        if(nEventTotal > WSA_MAXIMUM_WAIT_EVENTS)
                        {
                            printf(" Too many connections! /n");
                            continue;
                        }
                        SOCKET sNew = ::accept(sockArray[i], NULL, NULL);   //TCP握手
                        WSAEVENT event = ::WSACreateEvent();
                        ::WSAEventSelect(sNew, event, FD_READ|FD_CLOSE|FD_WRITE);
                        // 添加到表中
                        eventArray[nEventTotal] = event;
                        sockArray[nEventTotal] = sNew;
                        nEventTotal++;
                    }
                }
                else if(event.lNetworkEvents & FD_READ)         // 处理FD_READ通知消息
                {
                    if(event.iErrorCode[FD_READ_BIT] == 0)
                    {
                        char szText[256];
                        int nRecv = ::recv(sockArray[i], szText, strlen(szText), 0);
                        if(nRecv > 0)
                        {
                            szText[nRecv] = '/0';
                            printf("接收到数据：%s /n", szText);
                        }
                    }
                }
                else if(event.lNetworkEvents & FD_CLOSE)        // 处理FD_CLOSE通知消息
                {
                    if(event.iErrorCode[FD_CLOSE_BIT] == 0)
                    {
                        ::closesocket(sockArray[i]);
                        for(int j=i; j<nEventTotal-1; j++)
                        {
                            sockArray[j] = sockArray[j+1];
                            sockArray[j] = sockArray[j+1];
                        }
                        nEventTotal--;
                    }
                }
                else if(event.lNetworkEvents & FD_WRITE)        // 处理FD_WRITE通知消息
                {
                }
            }
        }
    }
// 事件句柄和套节字句柄表
WSAEVENT eventArray[WSA_MAXIMUM_WAIT_EVENTS];
SOCKET  sockArray[WSA_MAXIMUM_WAIT_EVENTS];
int nEventTotal = 0;

USHORT nPort = 6000; // 此服务器监听的端口号

// 创建监听套节字
SOCKET sListen = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(nPort);
sin.sin_addr.S_un.S_addr = INADDR_ANY;
if(::bind(sListen, (sockaddr*)&sin, sizeof(sin)) == SOCKET_ERROR)
{
printf(" Failed bind() /n");
return -1;
}
::listen(sListen, 5);

// 创建事件对象，并关联到新的套节字
WSAEVENT event = ::WSACreateEvent();
::WSAEventSelect(sListen, event, FD_ACCEPT|FD_CLOSE);
// 添加到表中
eventArray[nEventTotal] = event;
sockArray[nEventTotal] = sListen;
nEventTotal++;

// 处理网络事件
while(TRUE)
{
  // 在所有事件对象上等待
  int nIndex = ::WSAWaitForMultipleEvents(nEventTotal, eventArray, FALSE, WSA_INFINITE, FALSE);
  // 对每个事件调用WSAWaitForMultipleEvents函数，以便确定它的状态
  nIndex = nIndex - WSA_WAIT_EVENT_0;//发生的事件对象的索引，一般是句柄数组中最前面的那一个，然后再用循环依次处理后面的事件对象
  for(int i=nIndex; i<nEventTotal; i++)
  {
   int ret;
   ret = ::WSAWaitForMultipleEvents(1, &eventArray[i], TRUE, 1000, FALSE);
   if(ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
   {
    continue;
   }
   else
   {
    // 获取到来的通知消息，WSAEnumNetworkEvents函数会自动重置受信事件
    WSANETWORKEVENTS event;
    ::WSAEnumNetworkEvents(sockArray[i], eventArray[i], &event);
    if(event.lNetworkEvents & FD_ACCEPT)    // 处理FD_ACCEPT通知消息
    {
     if(event.iErrorCode[FD_ACCEPT_BIT] == 0)
     {
      if(nEventTotal > WSA_MAXIMUM_WAIT_EVENTS)
      {
       printf(" Too many connections! /n");
       continue;
      }
      SOCKET sNew = ::accept(sockArray[i], NULL, NULL);
      WSAEVENT event = ::WSACreateEvent();
      ::WSAEventSelect(sNew, event, FD_READ|FD_CLOSE|FD_WRITE);
      // 添加到表中
      eventArray[nEventTotal] = event;
      sockArray[nEventTotal] = sNew;
      nEventTotal++;
     }
    }
    else if(event.lNetworkEvents & FD_READ)   // 处理FD_READ通知消息
    {
     if(event.iErrorCode[FD_READ_BIT] == 0)
     {
      char szText[256];
      int nRecv = ::recv(sockArray[i], szText, strlen(szText), 0);
      if(nRecv > 0)
      {
       szText[nRecv] = '/0';
       printf("接收到数据：%s /n", szText);
      }
     }
    }
    else if(event.lNetworkEvents & FD_CLOSE)  // 处理FD_CLOSE通知消息
    {
     if(event.iErrorCode[FD_CLOSE_BIT] == 0)
     {
      ::closesocket(sockArray[i]);
      for(int j=i; j<nEventTotal-1; j++)
      {
       sockArray[j] = sockArray[j+1];
       sockArray[j] = sockArray[j+1];
      }
      nEventTotal--;
     }
    }
    else if(event.lNetworkEvents & FD_WRITE)  // 处理FD_WRITE通知消息
    {
    }
   }
  }
}

TCP例子就是在监听套接字上关联一个事件对象以及FD_ACCEPT|FD_CLOSE网络事件。

下面是UDP的例子：

// 创建事件对象，并关联到新的套节字
WSAEVENT event = ::WSACreateEvent();
::WSAEventSelect(s, event, FD_READ|FD_CLOSE);

// 添加到表中
eventArray[nEventTotal] = event;
sockArray[nEventTotal] = s;
nEventTotal++;

// 处理网络事件
while(TRUE)
{
  // 在所有事件对象上等待
  int nIndex = ::WSAWaitForMultipleEvents(nEventTotal, eventArray, FALSE, WSA_INFINITE, FALSE);
  // 对每个事件调用WSAWaitForMultipleEvents函数，以便确定它的状态
  nIndex = nIndex - WSA_WAIT_EVENT_0;
  for(int i=nIndex; i<nEventTotal; i++)
  {
   int ret;
   ret = ::WSAWaitForMultipleEvents(1, &eventArray[i], TRUE, 1000, FALSE);
   if(ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
   {
    continue;
   }
   else
   {
    // 获取到来的通知消息，WSAEnumNetworkEvents函数会自动重置受信事件
    WSANETWORKEVENTS event;
    ::WSAEnumNetworkEvents(sockArray[i], eventArray[i], &event);
    if(event.lNetworkEvents & FD_READ)   // 处理FD_READ通知消息
    {
     if(event.iErrorCode[FD_READ_BIT] == 0)
     {
      char szText[256];
      int nRecv = ::recv(sockArray[i], szText, strlen(szText), 0);
      if(nRecv > 0)
      {
       szText[nRecv] = '/0';
       printf("接收到数据：%s /n", szText);
      }
     }
    }


   }

  }

}

UDP例子就是在一个普通套接字上关联一个事件对象以及FD_READ网络事件。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/wanjingwei/archive/2009/06/29/4306609.aspx

yuntongsf

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
套接字I/O模型之WSAEventSelect

套接字模式和套接字I/O模型的区别。套接字模式：阻塞套接字和非阻塞套接字。或者叫同步套接字和异步套接字。套接字模型：描述如何对套接字的I/O行为进行管理。 Winsock提供的I/O模型一共有五种： select,WSAAsyncSelect,WSAEventSelect,Overlapped,Completion。 1：select模型（选择模型）先看一下下面的这句
复制链接

扫一扫