Windows下select模型

阻塞模式和非阻塞模式的优点和不足:

阻塞模式套接字执行IO操作时，如果执行操作的条件未满足，线程就会阻塞在调用的函数上。程序不得不处于等待状态，但是由于并不知道客户请求何时到来，因此函数在何时返回不得而知。

非阻塞模式套接字执行IO操作时，在任何时候函数都会立即返回。但程序员必须为此编写更多的代码。这增加了开发Windows socket应用程序的难度。另外由于不断的循环调用导致程序效率很低。

select模型是一种比较常用的IO模型。利用该模型可以使Windows socket应用程序可以同时管理多个套接字。使用select模型，可以使当执行操作的套接字满足可读可写条件时，给应用程序发送通知。收到这个通知后，应用程序再去调用相应的Windows socket API去执行函数调用。

Select模型的核心是select函数。调用select函数检查当前各个套接字的状态。根据函数的返回值判断套接字的可读可写性。然后调用相应的Windows Sockets API完成数据的发送、接收等。

Select模型是Windows sockets中最常见的IO模型。它利用select函数实现IO 管理。通过对select函数的调用，应用程序可以判断套接字是否存在数据、能否向该套接字写入数据。如：在调用recv函数之前，先调用select函数，如果系统没有可读数据那么select函数就会阻塞在这里。当系统存在可读或可写数据时，select函数返回，就可以调用recv函数接收数据了。

select函数

[cpp] view plain copy

int select (
Int nfds,//被忽略。传入0即可。
fd_set *readfds,//可读套接字集合。
fd_set *writefds,//可写套接字集合。
fd_set *exceptfds,//错误套接字集合。
const struct timeval*timeout);//select函数等待时间。

该函数返回处于就绪态并且已经被包含在fd_set结构中的套接字总数。如果超时则返回0。

第一个参数nfds被忽略。

第二个参数readfds，可读性套接字集合指针。

第三个参数writefds，可写性套接字集合指针。

第四个参数exceptfds，检查错误套接字集合指针。

第五个参数timeout，等待时间。

fd_set结构是一个结构体。

[cpp] view plain copy

typedef struct fd_set
{
u_int fd_count;
socket fd_array[FD_SETSIZE];
}fd_set;

fd_cout表示该集合套接字数量。最大为64.

fd_array套接字数组。

select函数中需要三个fd_set结构:

一：准备接收数据的套接字集合，即可读性集合。

二：准备发送数据的套接字集合，即可写性集合。

在select函数返回时，会在fd_set结构中，填入相应的套接字。

readfds数组将包括满足以下条件的套接字：

1：有数据可读。此时在此套接字上调用recv，立即收到对方的数据。

2：连接已经关闭、重设或终止。

3：正在请求建立连接的套接字。此时调用accept函数会成功。

writefds数组包含满足下列条件的套接字：

1：有数据可以发出。此时在此套接字上调用send,可以向对方发送数据。

2：调用connect函数，并连接成功的套接字。

exceptfds数组将包括满足下列条件的套接字：

1：调用connection函数，但连接失败的套接字。

2：有带外（out of band）数据可读。

select函数的使用:

在调用select函数对套接字进行监视之前，必须将要监视的套接字分配给上述三个数组中的一个。然后调用select函数，再次判断需要监视的套接字是否还在原来的集合中。就可以知道该集合是否正在发生IO操作。

例如：应用程序想要判断某个套接字是否存在可读的数据，需要进行如下步骤：

1：将该套接字加入到readfds集合。

2：以readfds作为第二个参数调用select函数。

3：当select函数返回时，应用程序判断该套接字是否仍然存在于readfds集合。

4：如果该套接字存在与readfds集合，则表明该套接字可读。此时就可以调用recv函数接收数据。否则，该套接字不可读。

在调用select函数时，readfds、writefds和exceptfds三个参数至少有一个为非空。并且在该非空的参数中，必须至少包含一个套接字。否则select函数将没有任何套接字可以等待。

timeval结构体用于定义select的等待时间。

[cpp] view plain copy

structure timeval
{
long tv_sec;//秒。
long tv_usec;//毫秒。
};

当timeval为空指针时，select会一直等待，直到有符合条件的套接字时才返回。

当tv_sec和tv_usec之和为0时，无论是否有符合条件的套接字，select都会立即返回。

当tv_sec和tv_usec之和为非0时，如果在等待的时间内有套接字满足条件，则该函数将返回符合条件的套接字。如果在等待的时间内没有套接字满足设置的条件，则select会在时间用完时返回，并且返回值为0。

为了方便使用，windows sockets提供了下列宏，用来对fd_set进行一系列操作。使用以下宏可以使编程工作简化。

FD_CLR(s,*set);从set集合中删除s套接字。

FD_ISSET(s,*set);检查s是否为set集合的成员。

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

FD_ZERO(*set);将set集合初始化为空集合。

在开发Windows sockets应用程序时，通过下面的步骤，可以完成对套接字的可读写判断:

1：使用FD_ZERO初始化套接字集合。如FD_ZERO(&readfds);

2:使用FD_SET将某套接字放到readfds内。如： FD_SET(s,&readfds);

3:以readfds为第二个参数调用select函数。select在返回时会返回所有fd_set集合中套接字的总个数，并对每个集合进行相应的更新。将满足条件的套接字放在相应的集合中。

4:使用FD_ISSET判断s是否还在某个集合中。如： FD_ISSET(s,&readfds);

5:调用相应的Windows socket api 对某套接字进行操作。

select返回后会修改每个fd_set结构。删除不存在的或没有完成IO操作的套接字。这也正是在第四步中可以使用FD_ISSET来判断一个套接字是否仍在集合中的原因。

看例子，该例演示了一个服务器程序使用select模型管理套接字。

#include <WinSock2.h>  
#include <Windows.h>  
#include <MSWSock.h>  
#include <stdio.h>  
#include <map>  
using namespace std;  


#pragma comment(lib,"Ws2_32.lib")  
#pragma comment(lib,"Mswsock.lib")  

 
int main()  
{  
    WSAData wsaData;  
    if(0 != WSAStartup(MAKEWORD(2,2),&wsaData))  
    {  
        printf("初始化失败!%d\n",WSAGetLastError());  
        Sleep(5000);  
        return -1;  
    }  
	
    USHORT nport = 6000;  
    SOCKET sListen = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);  
	
	u_long ul = 1;  
    ioctlsocket(sListen,FIONBIO,&ul);  
	
    sockaddr_in sin;  
    sin.sin_family = AF_INET;  
    sin.sin_port = htons(nport);  
    sin.sin_addr.S_un.S_addr = ADDR_ANY;  
	
	
    if(SOCKET_ERROR == bind(sListen,(sockaddr*)&sin,sizeof(sin)))  
    {  
        printf("bind failed!%d\n",WSAGetLastError());  
        Sleep(5000);  
        return -1;  
    }  
	
	
    listen(sListen,5);  
	
	
    //1)初始化一个套接字集合fdSocket，并将监听套接字放入  
    fd_set socketSet;  
    FD_ZERO(&socketSet);  
    FD_SET(sListen,&socketSet);  
	
    TIMEVAL time={1,0};  
    char buf[4096];  
	
	
    fd_set    readSet;  
    FD_ZERO(&readSet);  
	
    fd_set    writeSet;  
    FD_ZERO(&readSet);  
	 
	
    while(true)  
    {  
        //2）将fdSocket的一个拷贝fdRead传给select函数  
		readSet = socketSet;   
		writeSet = socketSet;   
		
		//同时检查套接字的可读可写性。
        int   nRetAll = select(0,&readSet,&writeSet,NULL,NULL/*&time*/);//若不设置超时则select为阻塞  
        if(nRetAll >0 )   //-1
		{  
			//是否存在客户端的连接请求。  
			if(FD_ISSET(sListen ,&readSet))//在readset中会返回已经调用过listen的套接字。  
			{  
				
				if(socketSet.fd_count < FD_SETSIZE)  
				{  
					sockaddr_in addrRemote;  
					int nAddrLen = sizeof(addrRemote);  
					SOCKET sClient = accept(sListen,(sockaddr*)&addrRemote,&nAddrLen); 
					if(sClient!=INVALID_SOCKET)  
					{ 
						FD_SET(sClient,&socketSet);  
						printf("\n接收到连接：(%s)",inet_ntoa(addrRemote.sin_addr));  
					}
				}  
				else  
				{  
					printf("连接数量已达上限！\n");  
					continue;  
				}   
			}  
			
			
			for(int i=0;i<socketSet.fd_count;i++)  
			{  
				if(FD_ISSET(socketSet.fd_array[i], &readSet)  )  
				{  
					//调用recv，接收数据。 
					int nRecv = recv(socketSet.fd_array[i],buf,4096,0);  
					if(nRecv > 0)  
					{  
						buf[nRecv] = 0;  
						printf("\nrecv  %d :  %s", socketSet.fd_array[i],buf);  
					}  
				}  

				if(FD_ISSET(socketSet.fd_array[i] , &writeSet)  )
				{   

				      //调用send，发送数据。
					    char buf[]="hello!"; 
                        int nRet = send(socketSet.fd_array[i],buf, strlen(buf)+1 ,0);   
                        if(nRet <= 0)  
                        {  
                            if(GetLastError() == WSAEWOULDBLOCK)  
                            {  
								//do nothing  
                            }  
                            else  
                            {  
                                closesocket(socketSet.fd_array[i]);   
                                FD_CLR(socketSet.fd_array[i],&socketSet);  
                            }   
						}
						else 
						{
						  	printf("\nsend  hello!");
						}
				}  
			}  
			
		}  
        else if(nRetAll == 0)  
        {  
			printf("time out!\n");  
        }  
        else  
        {  
            printf("select error!%d\n",WSAGetLastError());  
            Sleep(5000);  
            break;  
        }  
		
		 Sleep(1000);

    }  
    closesocket(sListen);  
    WSACleanup();  
}

客户端

#include<stdlib.h>
#include<WINSOCK2.H>
 #include <windows.h> 
#include <process.h>  

#include<iostream>
#include<string>
using namespace std;

#define BUF_SIZE 64
#pragma comment(lib,"WS2_32.lib")


void recv(PVOID pt)  
{  
	    SOCKET  sHost=  *((SOCKET *)pt);

      	while(true)
		{
		    char buf[BUF_SIZE];//清空接收数据的缓冲区
			memset(buf,0 , BUF_SIZE);
			int retVal=recv(sHost,buf,sizeof(buf),0);
			if(SOCKET_ERROR==retVal)
			{
				int  err=WSAGetLastError();
				//无法立即完成非阻塞Socket上的操作
				if(err==WSAEWOULDBLOCK)
				{
					Sleep(1000);
					printf("\nwaiting  reply!");
					continue;
				}
				else if(err==WSAETIMEDOUT||err==WSAENETDOWN|| err==WSAECONNRESET)//已建立连接
				{
					printf("\nrecv failed!");
					closesocket(sHost);
					WSACleanup();
					return  ;
				}

			}

				Sleep(100);

	        	printf("\n%s", buf);
			 //break;
		} 
}  


int main()
{
	WSADATA wsd;
	SOCKET sHost;
	SOCKADDR_IN servAddr;//服务器地址
	int retVal;//调用Socket函数的返回值
	char buf[BUF_SIZE];
	//初始化Socket环境
	if(WSAStartup(MAKEWORD(2,2),&wsd)!=0)
	{
		printf("WSAStartup failed!\n");
		return -1;
	}
	sHost=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
	//设置服务器Socket地址
	servAddr.sin_family=AF_INET;
	servAddr.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
	//在实际应用中，建议将服务器的IP地址和端口号保存在配置文件中
	servAddr.sin_port=htons(6000);
	//计算地址的长度
	int sServerAddlen=sizeof(servAddr);
	
	
	
 	//调用ioctlsocket（）将其设置为非阻塞模式
   int iMode=1;
	retVal=ioctlsocket(sHost,FIONBIO,(u_long FAR*)&iMode); 
	
	
	if(retVal==SOCKET_ERROR)
	{
		printf("ioctlsocket failed!");
		WSACleanup();
		return -1;
	}
	
	
	//循环等待
	while(true)
	{
		//连接到服务器
		retVal=connect(sHost,(LPSOCKADDR)&servAddr,sizeof(servAddr));
		if(SOCKET_ERROR==retVal)
		{
			int err=WSAGetLastError();
			//无法立即完成非阻塞Socket上的操作
			if(err==WSAEWOULDBLOCK||err==WSAEINVAL)
			{
				Sleep(1);
				printf("check  connect!\n");
				continue;
			}
			else if(err==WSAEISCONN)//已建立连接
			{
				break;
			}
			else
			{
				printf("connection failed!\n");
				closesocket(sHost);
				WSACleanup();
				return -1;
			}
		}
	}
	
	
    unsigned long     threadId=_beginthread(recv,0,&sHost);//启动一个线程接收数据的线程   


	
	while(true)
	{
		//向服务器发送字符串，并显示反馈信息
		printf("input a string to send:\n");
		std::string str;
		//接收输入的数据
		std::cin>>str;
		//将用户输入的数据复制到buf中
		ZeroMemory(buf,BUF_SIZE);
		strcpy(buf,str.c_str());
		if(strcmp(buf,"quit")==0)
		{
			printf("quit!\n");
			break;
		}
		
		while(true)
		{
			retVal=send(sHost,buf,strlen(buf),0);
			if(SOCKET_ERROR==retVal)
			{
				int err=WSAGetLastError();
				if(err==WSAEWOULDBLOCK)
				{
					//无法立即完成非阻塞Socket上的操作
					Sleep(5);
					continue;
				}
				
				else
				{
					printf("send failed!\n");
					closesocket(sHost);
					WSACleanup();
					return -1;
				}
			}
			break;
		}
		  
		
	}
	
	return 0;
}

Windows下select模型

继续阅读

【网络篇】第五篇——网络套接字编程(一)(socket详解)socket编程LINUX下socket程序的演示

windows命令行工具(转)

网络空间安全中高职业院校职技能大赛——Telnet弱口令渗透测试

论文阅读笔记（三）：Research on Network Attack Effect Evaluation Based on Confrontational Perspective一. 论文简介二. 创新点和贡献：三. 相关领域的概述(related work)四. 作者的方案五. 主要的信息流（approach）六. 总结

2.H3CNE-网络参考模型

解读2008年网络技术热词之云计算

《eWEEK》：09年5大科技发展趋势云计算居首

《正在爆发的互联网革命》

浅谈使用Fiddler工具进行弱网测试

linux网络编程----发送与接收文件

PHP进阶学习之session写入数据库

CSMA/CD1． CSMA/CD的概述2． CSMA 的工作原理3． CSMA/CD控制规程及特点4． CSMA/CD协议5． CSMA/CD的优点6．结束语

手动安装Intel network I217-LM网卡的Linux驱动

XX系统实施过程问题总结

nginx 安装错误信息解决

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？