套接字I/O模型-select

共有6种类型套接字I/O模型。blocking（阻塞），select（选择），WSAAsyncSelect（异步选择），WSAEventSelect（事件选择），overlapped（重叠），completionport（完成端口）。

1.select

之所以称select模型，是因为工作原理是利用select函数实现对I/O的管理。

select可用于判断套接字上是否存在数据，或者能否向一个套接字写入数据，之所以要设计这个函数，其目的是防止应用程序在套接字处于阻塞模式时，在I/O绑定调用（如send或recv）过程中进入阻塞状态；同时也放在套接字处于非阻塞模式中时，产生WSAEWOULDBLOCK错误，除非满足事先用参数规定的条件，否则select函数在进行I/O操作时会阻塞。

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

nfds会被忽略，之所以保留是为了与早期套接字兼容

3个fd_sed，readfds用于检测可读性，writefds用于检测可写性，exceptfds用于外地数据，从根本上讲，fd_set数据类型代表着一系列特定套接字结合。

readfds集合包括符合下述任何一个条件的套接字：

.有数据可以读入

.连接已经被关闭，终止或重启

.假如已调用了listen，而且有一个连接正处于搁置状态，那么accept调用会成功 

writefds集合包括符合下述任何一个条件的套接字：

.有数据可以发出

.如果正在对一个非阻塞连接调用进行处理，则连接就成功

exceptfds集合包括符合下述任何一个条件的套接字：

.如果正在对一个非阻塞连接调用进行处理，连接尝试将会失败

.有OOB（out-of-band，外地）数据可供读写

假设我们想测试一个套接字是否可读，必须将套接字添加到readfds集合中，在等待select函数完成。当select调用完成后，必须判断这个套接字是否仍为readfds中的一部分。若是，则表明该套接字可读，可立即进行读取数据。在3个参数中，任何两个都可以是NULL，但至少有一个不能为NULL,在任何不为空的集合中，必须包含至少一个套接字句柄，否则select没有任何东西可以等待。timeout对应的是一个指针，指向一个timeval结构，用于决定select等待I/O操作完成时，最多等待多长时间。如果timeout是一个空指针，那么select调用会无限期处于阻塞状态，直到至少有一个描述符与指定条件相符才结束。

struct timeval
{
  long tv_sec;//秒为单位指定等待时间
  long tv_usec;//以毫秒为单位指定等待时间
};
//若将时间设置为{0,0}表明select会立即返回。处于对性能考虑，应避免这么设置

对fd_set集合进行处理与检查：

FD_ZERO(*set);//将set初始化为空集合，集合在使用前都要清空

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

FD_ISSET(s, *set);//检测s是否是set中的一个成员，如果是，返回TRUE

FD_SET(s, *set);//将套接字s加入到set中

采用以下步骤便可完成select操作一个或多个套接字句柄的全过程：

1.使用FD_ZERO初始化自己感兴趣的每个fd_set

2.使用FD_SET将套接字句柄分配给自己感兴趣的fd_set

3.调用select函数，然后等待直到I/O活动在在指定的fd_set集合中设置好了一个或多个套接字句柄。select完成后，会返回在所有fd_set集合中设置的套接字句柄总数，并对每个集合进行相应的更新

4.根据select的返回值，应用程序便可判断哪些套接字存在着被搁置的I/O操作--具体的方法是使用FD_ISSET宏，对每个fd_set进行检查

5.知道了每个集合中被挂起的I/O操作之后，对I/O进行处理，然后返回步骤1，继续处理select

select返回后，它会修改每个fd_set结构。删除那些不存在被挂起的I/O操作的套接字句柄。

示例代码

SOCKET s;
fd_set fdread;
int ret;

//创建套接字，接受连接

//在套接字上管理I/O
while(true)
{
  //在调用select前，清楚读出集
  FD_ZERO(&fdread);
  //将s添加到读出集
  FD_SET(s, &fdread);
  if((ret=select(0, &fdread, NULL, NULL, NULL))==SOCKET_ERROR)
  {
    //条件出错
  }

  if(ret>0)
  {
    //
    //
    if(FD_ISSET(s, &fdread))
    {
      //套接字s上已发生了一个事件
    }
  }
}

使用select的优势是能够从当个线程的多个套接字上进行多重连接及I/O。

 

=======================================================================

客户端代码：

这是一个最简单的客户端代码，负责发送数据，然后接受返回。

#include<stdio.h>
#include<winsock2.h>
#pragma comment(lib, "ws2_32.lib")

#define SERVER_IP "192.168.1.222"
#define PORT 5150
#define MSGSIZE 1024

int main()
{
  WSADATA wsaData;
  SOCKET sClient;
  SOCKADDR_IN server;
  char szMessage[MSGSIZE];
  int ret;

  WSAStartup(MAKEWORD(2,2), &wsaData);
  sClient = socket(AF_INET, SOCK_STREAM,  IPPROTO_TCP);
  memset(&server, 0, sizeof(server));
  server.sin_family = AF_INET;
  server.sin_port = htons(PORT);
  server.sin_addr.s_addr = inet_addr(SERVER_IP);

  connect(sClient, (sockaddr*)&server, sizeof(SOCKADDR_IN));
  while(TRUE)
  {
    printf("Send:");
    gets(szMessage);
    send(sClient, szMessage, strlen(szMessage), 0);
    ret = recv(sClient, szMessage, MSGSIZE, 0);
    szMessage[ret] = '\0';
    printf("Received [%d bytes]: '%s'\n", ret, szMessage);
  }
  closesocket(sClient);
  WSACleanup();

  //system("pause");
  return 0;
}

 

服务端代码：

这是异步模型中最简单的一种，服务器端的几个主要流程如下： 

1.创建监听套接字，绑定，监听； 

2.创建工作者线程； 

3.创建一个套接字数组，用来存放当前所有活动的客户端套接字，每accept一个连接就更新一次数组； 

4.接受客户端的连接。

#include<stdio.h>
#include<winsock2.h>
#pragma comment(lib, "ws2_32.lib")

#define PORT 5150
#define MSGSIZE 1024

int g_iTotalConn = 0;
SOCKET g_CliSocketArr[FD_SETSIZE];
DWORD WINAPI WorkerThread(LPVOID lpParam);

int main()
{
    WSADATA wsaData;
    SOCKET sListen, sClient;
    SOCKADDR_IN local, client;
    int iAddrSize = sizeof(SOCKADDR_IN);
    DWORD dwThreadId;

    WSAStartup(MAKEWORD(2,2), &wsaData);
    sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    memset(&local, 0, sizeof(SOCKADDR_IN));
    local.sin_family = AF_INET;
    local.sin_port = htons(PORT);
    local.sin_addr.s_addr = htonl(INADDR_ANY);

    bind(sListen, (sockaddr*)&local, sizeof(SOCKADDR_IN));
    listen(sListen, 5);

    CreateThread(NULL, 0 , WorkerThread, NULL, 0, &dwThreadId);

    while(TRUE)
    {
      sClient = accept(sListen, (sockaddr*)&client, &iAddrSize);
      printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
      g_CliSocketArr[g_iTotalConn++] = sClient;
    }

    return 0;
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
  fd_set fdread;
  int ret;
  int i;
  struct timeval tv = {1,0};
  char szMessage[MSGSIZE];
  while(TRUE)
  {
    FD_ZERO(&fdread);
    for(i=0; i<g_iTotalConn; ++i)
    {
      FD_SET(g_CliSocketArr[i], &fdread);
    }
    ret = select(0, &fdread, NULL, NULL, NULL);
    if(0 == ret)
    {
      continue;
    }
    for(i=0; i<g_iTotalConn; ++i)
    {
      if(FD_ISSET(g_CliSocketArr[i], &fdread))
      {
        ret = recv(g_CliSocketArr[i], szMessage, MSGSIZE, 0);
        if(0 == ret || (ret==SOCKET_ERROR && WSAGetLastError()==WSAECONNRESET))
        {
          printf("Client socket %d closed.\n", g_CliSocketArr[i]);
          closesocket(g_CliSocketArr[i]);
          if(i<g_iTotalConn-1)
          {
            g_CliSocketArr[i--] = g_CliSocketArr[--g_iTotalConn];
          }
        }
        else
        {
          szMessage[ret] = '\0';
          send(g_CliSocketArr[i], szMessage, strlen(szMessage), 0);
        }
      }
    }
  }
}