基于事件通知的重叠I/O网络模型

最新推荐文章于 2021-04-17 21:44:35 发布
原创 最新推荐文章于 2021-04-17 21:44:35 发布 · 1k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络 #socket #io #事件 #重叠IO

本文介绍了一个基于事件通知的重叠IO网络模型实现，详细解释了如何使用WSAGetOverlappedResult等API来处理异步I/O操作，包括客户端连接处理、数据接收和发送流程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这里就补充一个API就足够了，其余的在基于完成例程的重叠IO网络模型中有详尽的解释，这里且就不一一赘述

重要API

WSAGetOverlappedResult

BOOL WSAAPI WSAGetOverlappedResult(
  _In_   SOCKET s,  
  _In_   LPWSAOVERLAPPED lpOverlapped, 
  _Out_  LPDWORD lpcbTransfer, 
  _In_   BOOL fWait,    
  _Out_  LPDWORD lpdwFlags
);

s [in]
标识套接字的描述符。

lpOverlapped [in]
指向重叠操作开始时指定的WSAOVERLAPPED结构的指针。这个参数不能是一个NULL指针。

lpcbTransfer [out]
指向32位变量的指针，该变量存储经过接收操作、发送操作或WSAIoctl函数实际传输的字节数。这个参数不能是一个NULL指针。

fWait [in]
一个标志，指定函数是否应等待挂起的重叠操作完成。如果为TRUE，则在操作完成之前，该功能不会返回。如果FALSE且该操作仍处于挂起状态，则函数返回FALSE，WSAGetLastError函数返回WSA_IO_INCOMPLETE。仅当选择为基于事件通知的重叠操作时，fWait参数才可以设置为TRUE。

lpdwFlags [out]
指向一个32位变量的指针，它将接收一个或多个补充完成状态的标志。如果重叠操作是通过WSARecv或WSARecvFrom启动的，则此参数将包含lpFlags参数的结果值。这个参数不能是一个NULL指针。

功能
该函数返回指定套接字上重叠操作的结果。

返回值
如果WSAGetOverlappedResult成功，则返回值为TRUE。 这意味着重叠的操作已经成功完成，并且lpcbTransfer指向的值已被更新。
如果WSAGetOverlappedResult返回FALSE，则表示重叠操作未完成，重叠操作完成但出错，或者由于WSAGetOverlappedResult的一个或多个参数错误，无法确定重叠操作的完成状态。 失败时，lpcbTransfer指向的值不会被更新。 使用WSAGetLastError来确定失败的原因（通过WSAGetOverlappedResult函数或关联的重叠操作）。

错误码及含意
WSANOTINITIALISED：在使用这个函数之前，一个成功的WSAStartup调用必须发生。
WSAENETDOWN：网络子系统失败。
WSA_INVALID_HANDLE：WSAOVERLAPPED结构的hEvent参数不包含有效的事件对象句柄。
WSA_INVALID_PARAMETER：其中一个参数是不可接受的。
WSA_IO_INCOMPLETE：fWait参数为FALSE时产生该错误，表示I / O操作尚未完成。
WSAEFAULT：一个或多个lpOverlapped，lpcbTransfer或lpdwFlags参数不在用户地址空间的有效部分中。 如果lpOverlapped，lpcbTransfer或lpdwFlags参数在Windows Server 2003和更早版本上是空指针，则会返回此错误。

源码分析

1.实现流程图
实现流程图

2.源码
OverlapIOModel.h

#pragma once
#include "Socket.h"

#define MSGSIZE 1024

/************************************************************************/
/* 注意，此处的 WSAOVERLAPPED 不一定要在首部，区分和完成例程的区别（完成例程中有解释） 
/************************************************************************/
typedef struct
{
    WSAOVERLAPPED overlap;      // 这里保存的一个事件对象...缓冲区的位置
    WSABUF wsaBuf;              // 指明缓冲区的成员 
    char szMessage[MSGSIZE];    // 真正的缓冲区
    DWORD NumberOfBytesRecvd;   // 接收到的字节
    DWORD Flags;                // 是否成功接收
    SOCKADDR_IN addr;           // 客户端信息
    SOCKET sock;                // 套接字
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;


typedef void(*NetCallBack) (DWORD id, void* param, int len); // 定义消息处理函数指针


/************************************************************************/
/* 基于事件通知的重叠IO模型类 
/* Socket为自己封装的socket类
/************************************************************************/
class OverlapIOModel : public Socket
{
private:
    int g_iTotalConn;                                   // 总的连接数
    WSAEVENT g_CliEventArr[MAXIMUM_WAIT_OBJECTS];       // 事件对象数组
    LPPER_IO_OPERATION_DATA g_pPerIODataArr[MAXIMUM_WAIT_OBJECTS];  // 重叠结构数组

protected:
    // 消息处理函数
    NetCallBack NetFunc;    

    //begin accept
    void _BeginAccept();

    //clean client socket
    void Cleanup(int index);

    //service proc
    static DWORD WINAPI ServiceProc(LPARAM lparam);

public:
    OverlapIOModel();
    ~OverlapIOModel(); 

    //init net
    BOOL InitNet(NetCallBack func, UINT nSocketPOrt, LPCSTR lpszSocketAddr = ADDR_ANY); 

    //wsa send to client
    bool WSASendToClient(DWORD id, void* lparam);
};

InitNet

BOOL OverlapIOModel::InitNet(NetCallBack func, UINT nSocketPOrt, LPCSTR lpszSocketAddr /*= ADDR_ANY*/)
{
    NetFunc = func;
    if (!Create(nSocketPOrt, SOCK_STREAM, lpszSocketAddr))
        return false;
    if (!Listen(5))
        return false;
    CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)ServiceProc, this, NULL, NULL);
    _BeginAccept();
    return true;
}

初始化网络的一切信息，包括初始化网络环境，绑定，监听，并调用_BeginAccept开始接受客户端的连接

_BeginAccept

void OverlapIOModel::_BeginAccept()
{
    SOCKET sClient = 0;
    SOCKADDR_IN addrClient = { 0 };
    int nLen = sizeof(SOCKADDR_IN);
    int err = 0;

    while (true)
    {
        sClient = accept(m_hSocket, (sockaddr*)&addrClient, &nLen);
        if (sClient == INVALID_SOCKET)
            continue;

        printf("[%s:%d]->log on\n", inet_ntoa(addrClient.sin_addr), ntohs(addrClient.sin_port));

        g_pPerIODataArr[g_iTotalConn] = (LPPER_IO_OPERATION_DATA)HeapAlloc(// 在程序的默认堆上申请内存
            GetProcessHeap(),
            HEAP_ZERO_MEMORY,           
            sizeof(PER_IO_OPERATION_DATA));
        g_pPerIODataArr[g_iTotalConn]->sock = sClient;
        g_pPerIODataArr[g_iTotalConn]->addr = addrClient;
        g_pPerIODataArr[g_iTotalConn]->NumberOfBytesRecvd = 0;
        g_pPerIODataArr[g_iTotalConn]->wsaBuf.len = MSGSIZE;
        g_pPerIODataArr[g_iTotalConn]->wsaBuf.buf = g_pPerIODataArr[g_iTotalConn]->szMessage;
        //create net event
        g_CliEventArr[g_iTotalConn] = g_pPerIODataArr[g_iTotalConn]->overlap.hEvent = WSACreateEvent();

        //begin wsa recv(only can recv one time)
        if (SOCKET_ERROR == WSARecv(
            g_pPerIODataArr[g_iTotalConn]->sock,
            &(g_pPerIODataArr[g_iTotalConn]->wsaBuf),
            1,
            &(g_pPerIODataArr[g_iTotalConn]->NumberOfBytesRecvd),
            &(g_pPerIODataArr[g_iTotalConn]->Flags),
            &(g_pPerIODataArr[g_iTotalConn]->overlap),
            NULL))
        {
            err = WSAGetLastError();
            if (WSA_IO_PENDING != err) // WSA_IO_PENDING 重叠IO操作成功，等待稍后完成
            {
                HeapFree(GetProcessHeap(), 0, g_pPerIODataArr[g_iTotalConn]);
                printf("WSARecv failed:%d\n", err);
                continue;
            };
        }
        g_iTotalConn++;
    }
}

接受到客户端的连接后，将客户端的连接信息保存到结构体PER_IO_OPERATION_DATA全局数组变量g_pPerIODataArr中保存好信息，然后开始投递WSARecv异步操作，告诉操作系统帮我们接受该套接字的消息。

ServiceProc

/************************************************************************/
/* 基于事件通知的重叠IO网络模型的主要实现（工作线程）                        */
/************************************************************************/
DWORD WINAPI OverlapIOModel::ServiceProc(LPARAM lparam)
{
    OverlapIOModel* pOverLapIO = (OverlapIOModel*)lparam;
    int ret = 0;
    int index = 0;
    DWORD err = 0;
    while (TRUE)
    {
        //////////////////////////////////////////////////////////////////////////
        // 等待多个事件对象有信号发送
        ret = WSAWaitForMultipleEvents(pOverLapIO->g_iTotalConn, pOverLapIO->g_CliEventArr, FALSE, 1000, FALSE);
        if (ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
            continue;

        index = ret - WSA_WAIT_EVENT_0; // 获取索引值，此处 WSA_WAIT_EVENT_0 其实就等于0...

        //////////////////////////////////////////////////////////////////////////
        // 将事件对象设为无信号状态
        if (FALSE == WSAResetEvent(pOverLapIO->g_CliEventArr[index])) 
        {
            pOverLapIO->Cleanup(index);
            continue;
        }

        //////////////////////////////////////////////////////////////////////////
        // 获取重叠操作的结果，如果返回FALSE，表示重叠操作未完成
        if (FALSE == WSAGetOverlappedResult(  
            pOverLapIO->g_pPerIODataArr[index]->sock,
            &(pOverLapIO->g_pPerIODataArr[index]->overlap),
            &(pOverLapIO->g_pPerIODataArr[index]->NumberOfBytesRecvd),
            TRUE,
            &(pOverLapIO->g_pPerIODataArr[index]->Flags)))
        {
            printf("WSAGetOverlappedResult failed:%d\n", WSAGetLastError());
            continue;
        }

        //////////////////////////////////////////////////////////////////////////
        // 接收到的重叠结果的字节数为0是，表示客户端断开连接
        if (pOverLapIO->g_pPerIODataArr[index]->NumberOfBytesRecvd == 0)
        {
            printf("[%s:%d]->log off\n", 
                inet_ntoa(pOverLapIO->g_pPerIODataArr[index]->addr.sin_addr),
                ntohs(pOverLapIO->g_pPerIODataArr[index]->addr.sin_port));
            pOverLapIO->Cleanup(index);
        }
        else
        {
            //////////////////////////////////////////////////////////////////////////
            // 有数据接收到，对数据进行处理（NetFunc），并再投递一个异步请求（WSARecv）
            // 因为 WSARecv 只有一次生效的机会，如果我们在一次操作完之后，还有接下来的操作就还要继续投递一个WSARecv
            pOverLapIO->NetFunc(pOverLapIO->g_pPerIODataArr[index]->sock,
                pOverLapIO->g_pPerIODataArr[index]->szMessage,
                pOverLapIO->g_pPerIODataArr[index]->NumberOfBytesRecvd);

            ZeroMemory(pOverLapIO->g_pPerIODataArr[index]->szMessage,
                sizeof(pOverLapIO->g_pPerIODataArr[index]->szMessage));
            pOverLapIO->g_pPerIODataArr[index]->Flags = 0;

            if (SOCKET_ERROR == WSARecv( //create new WSARecv
                pOverLapIO->g_pPerIODataArr[index]->sock,
                &(pOverLapIO->g_pPerIODataArr[index]->wsaBuf),
                1,
                &(pOverLapIO->g_pPerIODataArr[index]->NumberOfBytesRecvd),
                &(pOverLapIO->g_pPerIODataArr[index]->Flags),
                &(pOverLapIO->g_pPerIODataArr[index]->overlap),
                NULL))
            {
                err = WSAGetLastError();
                if (WSA_IO_PENDING != err) // WSA_IO_PENDING 重叠IO操作成功，等待稍后完成
                {
                    HeapFree(GetProcessHeap(), 0, pOverLapIO->g_pPerIODataArr[index]);
                    printf("WSARecv failed:%d\n", err);
                };
            }
        }
    }
}

WSAWaitForMultipleEvents开始监听我们在接受套接字时绑定的网络事件对象是否有消息到来，如果客户端发来了数据并且事件对象有信号，此时必定是内核已经将数据拷贝到了我们WSABUF的缓冲区中（也就是PER_IO_OPERATION_DATA中的szMessage中），不必我们自己再去内核拷贝数据到用户空间中来。
接下来，我们对用户进行一些判断是否断线后，开始进行对数据进行处理，这里的处理是我们的处理函数指针NetFunc，函数指针的定义在头文件中有。
处理完数据后，我们再投递一次WSARecv。这样我们就完成了一次数据的收

WSASendToClient

/************************************************************************/
/* 进行消息发送的异步投递                                                 */
/************************************************************************/
bool OverlapIOModel::WSASendToClient(DWORD id, void* lparam)
{
    char* buf = (char*)lparam;
    int dwRet = 0;  
    WSABUF wsaBuf;
    wsaBuf.len = strlen(buf);
    wsaBuf.buf = buf;
    DWORD dwSendBytes = 0;
    DWORD Flags = 0;
    WSAOVERLAPPED overlap;
    overlap.hEvent = WSACreateEvent();

    // 投递一个WSASend给操作系统，让它帮助我们完成消息的发送
    if (SOCKET_ERROR == WSASend(id, &wsaBuf, 1, &dwSendBytes, Flags, &overlap, NULL))
    {
        dwRet = WSAGetLastError();
        if (dwRet != WSA_IO_PENDING)
        {
            printf("WSASend failed:%d\n", dwRet);
            return false;
        }
    }
    WSACloseEvent(overlap.hEvent);// 对发送的消息没有事件的检测，所以清除掉内核资源

    return true;
}

对数据进行处理之后，我们再通过WSASendToClient将数据处理之后结果发送给客户端，投递一个WSASend，让操作系统帮我们发送数据，同样是不占用自己程序的时间片，让用户程序做更多事情。

基于事件通知的重叠IO网络模型源码：http://pan.baidu.com/s/1o87OoHk

网络程序设计——重叠I/O模型
x20020402的博客
11-27 1113
对于网络重叠I/O操作，等待I/O操作结束的另一种方法是使用完成例程。异步的发送和接收接口函数的参数中的最后一个参数lpCompletionROUTINE就是用来指向完成例程的指针。若指定此参数，hEvent参数将被忽略，上下文信息将传送给完成例程函数。如果重叠操作立即完成，则返回0；如果重叠操作被成功初始化，并且稍后完成，则返回WSA_IO_PENDING。WinSock可以使用事件通知和完成例程两种方式来实现重叠I/O的操作。（3）两种获取传输数据数量的方法。
SOCKET之重叠I/O模型
vbanglev的小窝^_^
02-02 2604
首先要想再套接字上使用重叠I/O模型，首先必须使用WSA_FLAG_OVERLAPPED 这个标志创建套接字WSASocket(AF_INET,SOCKET_STREAM,0,NULL,0,WSA_FLAG_OVERLAPPED);如果创建套接字的时候使用socket 而不是WSASocket函数那默认会设者WSA_FLAG_OVERLAPPED标志随后将一个WSAOVERLAPPED
基于事件通知的重叠IO模型
11-03
本代码采用C++实现，在VS2015下开发，可以直接运行，代码中有相关的注释，如发现有问题，请不吝指教，谢谢！
重叠IO之事件通知模型
ldd909的专栏
02-14 1128
<br />/**********************************************************************<br />*   Author: JMF<br />*   Version:1.0<br />*   BUG: 最大只允许同时64个客户端同时连接(WSA_MAXIMUM_WAIT_EVENTS)<br />***********************************************************************/<b
重叠IO之事件对象通知(event object notification)
weixin_33984032的博客
06-23 111
http://www.cnblogs.com/gansaishi2008/archive/2008/07/25/1251641.html#2406576 转载于:https://www.cnblogs.com/vcdebug2010/archive/2012/06/23/2559511.html
SOCKET模型之重叠I/O篇(转贴)
weixin_33875839的博客
06-26 153
SOCKET模型之重叠I/O篇(转贴) 本文配套的示例源码下载地址(VC.net2003编写的多客户端MFC代码，配有详尽注释，只是简单的显示一下客户端发来的字符，稍加改进就是个聊天室了)：http://www.haha567.com/PiggyXP/OverlappedModel.rar(unix系统，千万注意链...
Socket I/O模型之重叠I/O(overlapped I/O)--事件通知
嗯.的专栏
05-04 913
C++代码 // write by larry   // 2009-8-20    // This is a server using overlapped IO(event notify).   #include "stdafx.h"   #include    #include    #pragma comment(lib, "ws2_32.lib")   #define PO
基于事件通知的重叠I/O网络模型-附件资源
03-05
基于事件通知的重叠I/O网络模型-附件资源
C++开发基于事件通知的Socket重叠I/O模型
标题和描述中提到的知识点包括：C++编程语言、Socket编程、重叠I/O模型以及事件通知机制。以下是对这些知识点的详细说明： 1. C++编程语言 C++是一种广泛使用的高级编程语言，具有面向对象编程、泛型编程和过程式...
采用事件通知形式的重叠I/O操作模型
01-28
总之，重叠I/O操作模型结合事件通知是Windows平台上高效处理网络通信和I/O密集型任务的关键技术。在C++中，借助Visual Studio 2010，开发者可以方便地实现这一机制，提升应用程序的性能和响应性。
C++实现采用事件通知的socket重叠I/O模型代码
01-28
本代码采用C++实现，在VS2010下开发，可以直接运行，代码中有相关的注释，如发现有问题，请不吝指教，谢谢！
用事件通知方式实现的重叠I/O模型
飞叶如刀
01-13 1066
//服务端源码 //用事件通知方式实现的重叠I/O模型 #include #include #define PORT 5566 #define MSGSIZE 1024 #pragma comment(lib, "ws2_32.lib") typedef struct { WSAOVERLAPPED overlap; WSABUF Buffer; char szMessage[MS
重叠IO
nihaowzw的博客
05-14 1023
#include <winsock2.h> #include <windows.h> #define PORT 6000 #define MSGSIZE 1024 #pragma comment (lib, "Ws2_32.lib") BOOL WinSockInit() { WSADATA data = { 0 }; if (WSAStartup(MAKEWORD(2, 2), &data)) r
重叠I/O之事件通知
_ACME_的博客
11-28 938
使用重叠I/O之事件通知模型步骤如下：一、打开服务器（包括初始化、创建socket、绑定、监听）其中创建socket的时候可以使用WSASocket，也可以简单的使用socket，因为socket默认已经加上了WSA_FLAG_OVERLAPPED这个标志。二、创建ThreadAccept线程这个线程主要是用来不断的接受client的请求，并为每一个成功连接到server的client创建一个事件对
模型设计与实践---（六）重叠IO，事件通知(Overlap Event)
fengsh998的专栏
04-17 2707
socketOverlappedEvent.h /******************************************************************** 创建时间: 2013/04/11 文件名: socketOverlappedEvent.h 描述: 重叠I/O 事件通知模式 作者: fengsh QQ : 19985430 电子邮
IO模型之重叠Overlapped IO基于事件通知
超级大洋葱的博客
04-17 1352
文章目录1. 重叠Overlapped IO模型2. 重叠Overlapped IO模型的优点3. 重叠IO请求的通知的方式4. 重叠I0基于事件通知的流程5. WSAOVERLAPPED结构体6. WSARecv函数7. WSASend函数8. WSABUF结构9. WSAWaitForMultipleEvents函数10. WSAGetOverlappedResult函数11. 基于事件通知的重叠IO编程步骤12. 服务端编程13. 客户端编程 1. 重叠Overlapped IO模型 重叠模型是让应用
事件通知方式实现的重叠I/O模型
liujiayu2的专栏
06-04 1398
////////////////////////////////////////////////////////////////////////// /// 事件通知方式实现的重叠I/O模型(异步IO模型) /// 这个模型的基本的设计实现是允许应用程序使用重叠的数据结构一次投递一个或者多个异步I/O /// 请求 /// 这个模型与上述其他模型不同的是它使用Winsock2提供的异步I/
基于事件的重叠IO模型
Barry的博客
12-19 3051
Windows socket重叠IO模型开发。        利用套接字重叠IO模型，应用程序能一次投递一个或多个IO请求，当系统完成IO操作后通知应用程序。该模型以win32异步IO机制为基础。与前面介绍的所有IO模型相比较，该模型是真正意义上的异步IO模型，它能使Windows socket应用程序达到更高的性能。      关于异步IO机制可以参考：《Windows
socket通信之六：Overlapped I/O 事件通知模型实现的客户/服务器模型
09-02 3460
1.基于事件通知模型的Overlapped I/O(重叠IO模型) 概括一点说，重叠模型是让应用程序使用重叠数据结构(WSAOVERLAPPED)，一次投递一个或多个Winsock I/O请求。针对这些提交的请求，在它们完成之后，应用程序会收到通知，于是就可以通过自己另外的代码来处理这些数据了。       需要注意的是，有两个方法可以用来管理重叠IO请求的完成情况（就是说接到
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值