1.什么是异步通知I/O模型
如图是同步I/O函数的调用时间流：
如图是异步I/O函数的调用时间流：
可以看出，同异步的差别主要是在时间流上的不一致。select属于同步I/O模型。epoll不确定是不是属于异步I/O模型，这个在概念上有些混乱，期望大佬的指点。
这里说的异步通知I/O模型，实际上是select模型的改进方案。
2.实现异步通知I/O模型
2.1 实现异步通知I/O模型步骤
2.2 WSAEventSelect函数
#include<winsock2.h>
int WSAEventSelect(
SOCKET s, //监视对象的套接字句柄
WSAEVENT hEventObject, //传递事件对象句柄以验证事件发生与否
long lNetworkEvents //监视的事件类型信息
);
成功返回0
失败返回SOCKET_ERROR参数hEventObject：
#define WSAEVENT HANDLEWSAEVENT就是HANDLE。
参数lNetworkEvents：
| 值 | 含义 |
| FD_READ | 是否存在需要接收的数据 |
| FD_WRITE | 能否以非阻塞的方式传输数据 |
| FD_OOB | 是否收到带外数据 |
| FD_ACCEPT | 是否有新的连接请求 |
| FD_CLOSE | 是否有断开连接的请求 |
可以通过位或运算指定多个信息。
函数解释：
传入的套接字参数s，只要s发送lNetworkEvents事件，就会将hEventObject事件对象所指内核对象的状态，改为signaled状态。
与select函数的比较：
每个通过WSAEventSelect函数注册的套接字信息就已经注册到操作系统中了，这意味着，无需针对已注册的套接字重复调用WSAEventSelect。
还有一个实现方式是WSAAsyncSelect函数，使用这个函数时需要指定Windows句柄以获取发生的事件（跟UI有关）
2.3 创建WSAEVENT对象
创建manual-reset模式的事件对象。
方式一：
使用“windows中的线程同步”中所讲的CreateEvent函数。
方式二：
#include<winsock2.h>
WSAEVENT WSACreateEvent(void);
成功返回事件对象句柄
失败返回WSA_INVALID_EVENT这种方式会直接创建manual-reset模式的事件对象。 其销毁函数：
#include<winsock2.h>
BOOL WSACloseEvent(WSAEVENT hEvent);
成功返回TRUE
失败返回FALSE2.4 验证是否发生了事件
#include<winsock2.h>
DWORD WSAWaitForMultipleEvent(
DWORD cEvents, //需要验证是否转为signaled状态的事件对象个数
const WSAEVENT* lphEvents, //存有事件对象句柄的数组地址值
BOOL fWaitAll, //TRUE,所有事件对象都在signaled状态时返回
//FALSE，只要其中1个变为signaled状态就返回
DWORD dwTimeout, //以1/1000秒为单位指定超时，传递WSA_INFINITE时，直到signaled状态时才返回
//传递0时，表明不阻塞，是否是signaled状态都返回
BOOL fAlertable //传递TRUE可进入alertable_wait(可警告等待)状态
);
成功：
返回值减去WSA_WAIT_EVENT_0时，可以得到第一个转变为signaled状态的事件对象句柄对应的索引，可在第二个参数中查找对应句柄。
超时则返回WSA_WAIT_TIMEOUT。
失败：
返回WSA_WAIT_FAILED（注意，原版书籍里这里打印错了）最多可监视的事件对象数量为：WSA_MAXIMUM_WAIT_EVENTS常量。
要想监视更多，要么创建线程，要么扩展保存句柄的数组并多次调用这个函数。
注意：参数fwaitAll为FALSE时，是说只要其中1个变为signaled状态就返回，函数是返回了，但其有可能有多个事件对象变为了signaled状态。
通过事件对象为manual-reset模式的特点，可以获取转为signaled状态的所有事件对象的句柄。
int start;
WSAEVENT events[num];
start=WSAWaitForMultipleEvents(num,events,FALSE,WSA_INFINITE,FALSE);
int first=start-WSA_WAIT_EVENT_0;
for(int i=first,i<num;++i) //first是变为singaled状态的事件对象的索引的最小值
{
//从第一个的signaled状态的事件对象开始，一个个判断是否siganled
int sigEventIdx=WSAWaitForMultipleEvents(1,&events[i],TRUE,0,FALSE);
......
}2.5 区分事件类型
#include<winsock2.h>
int WSAEnumNetworkEvents(
SOCKET s, //发生事件的套接字句柄
WSAEVENT hEventObject, //与套接字相连的signaled状态的事件对象句柄
LPWSANETWORKEVENTS lpNetworkEvents //保存发生的事件类型信息和错误信息的
//WSANETWORKEVENTS结构体变量地址值
);
成功返回0
失败返回SOCKET_ERRORstruct _WSANETWORKEVENTS
{
long lNetworkEvents; //事件类型
int iErrorCode[FD_MAX_EVENTS]; //错误信息
}WSANETWORKEVENTS,*LPWSANETWORKEVENTS;事件类型的验证：
就是FD_READ、FD_ACCEPT等，和WSAEventSelect第三个参数一样。
错误信息的验证：
如果发生FD_XXX相关错误，则在iErrorCode[FD_XXX_BIT]中保存除0以外的其他值。
如：
WSANETWORKEVENTS netEvents;
......
WSAEnumNetworkEvents(hSock,hEvent,netEvents);
......
if(netEvents.lNetworkEvents & FD_ACCEPT)
{
......
}
......
if(netEvents.iErrorCode[FD_READ_BIT]!=0)
{
......
}3.用异步通知I/O模型实现回声服务器端
#include<iostream>
#include<WinSock2.h>
#include<Windows.h>
#include<process.h>
#include<string>
#include<vector>
std::vector<SOCKET> vecSocket;
std::vector<WSAEVENT> vecEvent;
void ErrorHandle(WSANETWORKEVENTS network);
int main()
{
WSADATA wsaData;
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
std::cout << "start up fail!" << std::endl;
return 0;
}
SOCKET server = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (server == INVALID_SOCKET)
{
std::cout << "socket fail!" << std::endl;
return 0;
}
sockaddr_in serverAddr;
memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddr.sin_port = htons(9130);
if (SOCKET_ERROR == bind(server, (sockaddr*)&serverAddr, sizeof(serverAddr)))
{
std::cout << "bind fail!" << std::endl;
return 0;
}
if (SOCKET_ERROR == listen(server, 2))
{
std::cout << "listen fail!" << std::endl;
return 0;
}
WSAEVENT serverEvent=WSACreateEvent();
if (SOCKET_ERROR == WSAEventSelect(server, serverEvent, FD_ACCEPT))
{
std::cout << "event select fail!" << std::endl;
return 0;
}
vecSocket.push_back(server);
vecEvent.push_back(serverEvent);
while (1)
{
int eventSize = vecEvent.size();
int res=WSAWaitForMultipleEvents(eventSize, vecEvent.data(), FALSE, WSA_INFINITE, FALSE);
int a = (int)WSA_INVALID_EVENT;
if (res == WSA_WAIT_FAILED)
{
std::cout << "wait fail!" << std::endl;
//continue;
}
int first = res - WSA_WAIT_EVENT_0;
for (int i = first; i < eventSize; ++i)
{
int sig = WSAWaitForMultipleEvents(1, &vecEvent[i], TRUE, 0, FALSE);
if (sig == WSA_WAIT_FAILED)
continue;
int index = sig - WSA_WAIT_EVENT_0;
WSANETWORKEVENTS network;
int result = WSAEnumNetworkEvents(vecSocket[i], vecEvent[i], &network);
if (result == SOCKET_ERROR)
{
ErrorHandle(network);
}
else
{
if (network.lNetworkEvents & FD_ACCEPT)
{
SOCKET client;
sockaddr_in clientAddr;
memset(&clientAddr, 0, sizeof(clientAddr));
int clientAddrLen = sizeof(clientAddr);
client=accept(vecSocket[i], (sockaddr*)&clientAddr, &clientAddrLen);
if (INVALID_SOCKET==client)
{
std::cout << "accept fail!" << std::endl;
continue;
}
else
{
WSAEVENT clientEvent = WSACreateEvent();
WSAEventSelect(client, clientEvent, FD_READ|FD_CLOSE);
vecSocket.push_back(client);
vecEvent.push_back(clientEvent);
}
}
else if (network.lNetworkEvents & FD_READ)
{
char buff[1024];
int readLen=recv(vecSocket[i], buff, sizeof(buff), 0);
std::cout << "客户端发来的消息:" << buff << std::endl;
if (readLen != 0)
{
send(vecSocket[i], buff, readLen, 0);
}
}
else if (network.lNetworkEvents & FD_CLOSE)
{
closesocket(vecSocket[i]);
CloseHandle(vecEvent[i]);
auto itSocket = vecSocket.begin() + i;
if(itSocket<vecSocket.end())
vecSocket.erase(itSocket);
auto itEvent = vecEvent.begin() + i;
if (itEvent < vecEvent.end())
vecEvent.erase(itEvent);
}
}
}
}
CloseHandle(serverEvent);
closesocket(server);
WSACleanup();
return 0;
}
void ErrorHandle(WSANETWORKEVENTS network)
{
if (network.iErrorCode[FD_ACCEPT_BIT]!=0)
{
std::cout << "accept error!" << std::endl;
}
else if (network.iErrorCode[FD_READ_BIT] != 0)
{
std::cout << "read error!" << std::endl;
}
else if (network.iErrorCode[FD_CLOSE_BIT] != 0)
{
std::cout << "close error!" << std::endl;
}
}
