【网络】IO多路复用之IOCP

已于 2024-08-13 19:58:45 修改
阅读量873 收藏 15
点赞数 15
分类专栏： 网络 文章标签： 网络
于 2024-08-13 19:58:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abclui/article/details/141172420
版权

目录

一、工作原理

二、关键组件

三、使用步骤

四、IOCP示例

五、优点

六、缺点

七、应用场景

IOCP（Input/Output Completion Ports，输入输出完成端口）是Windows操作系统中一种高效的网络和文件I/O处理机制。它允许应用程序以异步方式处理多个I/O操作，同时能够减少线程的使用和提高系统的可扩展性。

一、工作原理

IOCP的核心思想是将I/O操作与具体的线程解耦，使用一个或多个完成端口来管理I/O操作的完成通知。当I/O操作（如socket的读写、文件的读写等）完成时，操作系统会将完成通知发送到与socket或文件句柄关联的完成端口。然后，一个或多个工作线程（Worker Threads）会从完成端口中取出这些完成通知，并对其进行处理。

二、关键组件

  1. 完成端口（Completion Port）：一个系统级的队列，用于存储I/O操作的完成通知。
  2. 工作线程（Worker Threads）：负责从完成端口中取出完成通知，并处理相应的I/O操作。
  3. I/O操作：如socket的accept、read、write等，以及与文件相关的读写操作。
  4. 关联：通过特定的API（如CreateIoCompletionPort）将句柄（如socket或文件句柄）与完成端口关联起来。

三、使用步骤

  1. 创建完成端口：使用CreateIoCompletionPort函数创建一个新的完成端口，或者将一个已存在的句柄（如无效句柄INVALID_HANDLE_VALUE）与完成端口关联。
  2. 关联句柄：使用CreateIoCompletionPort函数将需要异步处理的句柄（如socket句柄或文件句柄）与完成端口关联。
  3. 启动工作线程：创建并启动一个或多个工作线程，这些线程将循环调用GetQueuedCompletionStatus函数从完成端口中取出完成通知。
  4. 执行I/O操作：通过相应的API（如WSARecv、WSASend等）执行I/O操作，并指定完成端口作为操作的完成通知目标。
  5. 处理完成通知：在工作线程的GetQueuedCompletionStatus调用中，当I/O操作完成时，该函数会返回，并带有完成通知的相关信息（如完成状态、字节传输数等）。工作线程根据这些信息处理I/O操作的结果。

四、IOCP示例

tcpserver.h

#ifndef TCPSERVER_H
#define TCPSERVER_H
#include <winsock2.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <list>
#include <Mswsock.h>

#define MAXNUM   64
#define ONEPAGE 4096

#define NT_ACCEPT  0
#define NT_READ    1
struct MySocket{
    OVERLAPPED  m_olp;//事件
    SOCKET   m_socket; //接收链接的socket
    char     m_szBuffer[ONEPAGE];  //缓冲区
    char     m_nType; //网络事件的类型

};
// //sock--包大小，缓冲区，偏移量
//struct stru_pack{
//    int   m_nPackSize;
//    char *m_pszbuf;
//    int   m_noffset;
//};
class TCPServer
{
public:
    TCPServer();
    ~TCPServer();
public:
    bool initNetWork(const char* szip ="127.0.0.1",short nport = 1234);
    void unInitNetWork(const char *szerr = "");
    bool sendData(SOCKET sock,const char* szbuf,int nlen);
    bool postAccept();
    void postRecv(MySocket *);
public:

    static DWORD WINAPI ThreadProc(LPVOID lpvoid);
private:
    SOCKET m_socklisten;
    std::list<HANDLE> m_lstThread;
    std::list<MySocket*> m_lstSocket;
    bool  m_bFlagQuit;
    HANDLE m_hIOCP;
public:


};

#endif // TCPSERVER_H

tcpserver.cpp

#include "tcpserver.h"

TCPServer::TCPServer()
{
    m_socklisten = 0;
    m_bFlagQuit = true;


}

TCPServer::~TCPServer()
{

}

bool TCPServer::initNetWork(const char *szip, short nport)
{
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;

    /* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */
    wVersionRequested = MAKEWORD(2, 2);

    err = WSAStartup(wVersionRequested, &wsaData);
    if (err != 0) {
        /* Tell the user that we could not find a usable */
        /* Winsock DLL.                                  */
        printf("WSAStartup failed with error: %d\n", err);
        return false;
    }

    /* Confirm that the WinSock DLL supports 2.2.*/
    /* Note that if the DLL supports versions greater    */
    /* than 2.2 in addition to 2.2, it will still return */
    /* 2.2 in wVersion since that is the version we      */
    /* requested.                                        */

    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
        /* Tell the user that we could not find a usable */
        /* WinSock DLL.                                  */
        unInitNetWork("Could not find a usable version of Winsock.dll\n");
        return false;
    }
    else
        printf("The Winsock 2.2 dll was found okay\n");
    m_socklisten =  socket(AF_INET,SOCK_STREAM,0);
    if(INVALID_SOCKET == m_socklisten){
        unInitNetWork("socket err\n");
        return false;
    }
    sockaddr_in addrserver;
    addrserver.sin_family = AF_INET;
    addrserver.sin_port = htons(nport);
    addrserver.sin_addr.s_addr = 0;
    if(SOCKET_ERROR == bind(m_socklisten,(const struct sockaddr*)&addrserver,sizeof(addrserver))){
        unInitNetWork("bind err\n");
        return false;
    }
    if(SOCKET_ERROR == listen(m_socklisten,10)){
       unInitNetWork("listen err\n");
        return false;
    }
    //1.创建IOCP
    m_hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE,0,0,0);
    //2.将listen交给IOCP管理
    CreateIoCompletionPort((HANDLE)m_socklisten,m_hIOCP,m_socklisten,0);
    //3.创建空闲的socket
    SYSTEM_INFO si;
    GetSystemInfo(&si);
    for(unsigned int i = 0;i < si.dwNumberOfProcessors*2;i++){
        postAccept();
    }
    //4.创建线程池
//   //创建线程
     for(unsigned int i = 0;i < si.dwNumberOfProcessors*2;i++){
        HANDLE hThread = CreateThread(0,0,&ThreadProc,this,0,0);
        if(hThread)
            m_lstThread.push_back(hThread);
     }
    return true;
}

bool TCPServer::postAccept()
{
    MySocket *p= new MySocket;
    p->m_socket = socket(AF_INET,SOCK_STREAM,0);
    p->m_nType =NT_ACCEPT;
    p->m_olp.hEvent = WSACreateEvent();
    DWORD dwRecvNum;
    if(!AcceptEx(m_socklisten,
             p->m_socket,
             p->m_szBuffer,
             0,
             sizeof(sockaddr_in)+16,
             sizeof(sockaddr_in)+16,
             &dwRecvNum,
             &p->m_olp
                  )){
        if(WSAGetLastError() !=ERROR_IO_PENDING){
            closesocket(p->m_socket);
            WSACloseEvent(p->m_olp.hEvent);
            delete p;
            return false;

        }
      }

    m_lstSocket.push_back(p);
      return true;
}



DWORD TCPServer::ThreadProc(LPVOID lpvoid)
{
    TCPServer *pthis = (TCPServer*)lpvoid;
    DWORD dwNumberOfBytesTransferred;
    SOCKET sock;
    MySocket* psockex;
    DWORD dwFlag;
      while(pthis->m_bFlagQuit){
        //观察IOCP的状态
     dwFlag = GetQueuedCompletionStatus(pthis->m_hIOCP,
                                  &dwNumberOfBytesTransferred,
                                  (PULONG_PTR )&sock,
                                  (LPOVERLAPPED *)&psockex,
                                   INFINITE
                                  );
        if(!dwFlag){
            //如果客户端下线，需要将socket从链表中删掉
            auto ite = pthis->m_lstSocket.begin();
            while(ite !=pthis->m_lstSocket.end()){
                if((*ite) == psockex){
                    closesocket(psockex->m_socket);
                    WSACloseEvent(psockex->m_olp.hEvent);
                    delete psockex;
                    pthis->m_lstSocket.erase(ite);
                    break;
                }
                ite++;
            }
            continue;
     }
        if(!sock ||
         !psockex )
            continue;

        switch (psockex->m_nType) {
        case NT_ACCEPT:
        {
            //创建空闲额socktet
            pthis->postAccept();
            //主动投递接收数据请求
            pthis->postRecv(psockex);
            //将socket 交给IOCP管理
            CreateIoCompletionPort((HANDLE)psockex->m_socket,pthis->m_hIOCP,psockex->m_socket,0);
        }
            break;
        case NT_READ:
            printf("%s\n",psockex->m_szBuffer);
            pthis->postRecv(psockex);
            break;
        default:
            break;
        }

    }
    return 0;
}
void TCPServer::postRecv(MySocket *psockex)
{
    psockex->m_nType = NT_READ;
    WSABUF wb;
    wb.buf = psockex->m_szBuffer;
    wb.len = sizeof(psockex->m_szBuffer);
    DWORD dwNumberOfBytesRecvd;
    DWORD dwFlag = 0;
    if(WSARecv(psockex->m_socket,
            &wb,
            1,
            &dwNumberOfBytesRecvd,
            &dwFlag,
            &psockex->m_olp,
                0)){
        if(WSAGetLastError() != WSA_IO_PENDING ){

        }
    }
}

void TCPServer::unInitNetWork(const char *szerr )
{
    m_bFlagQuit = false;
    int nThreadNum =m_lstThread.size();
    while(nThreadNum-- >0){
        PostQueuedCompletionStatus(m_hIOCP,0,0,0);
    }
    for (auto& ite:m_lstThread) {

        if(WAIT_TIMEOUT == WaitForSingleObject(ite,100))
            TerminateThread(ite,-1);

        if(ite){
            CloseHandle(ite);
            ite = NULL;
        }
    }
    m_lstThread.clear();
    printf(szerr);
    if(m_socklisten){
       closesocket(m_socklisten);
        m_socklisten = 0;
    }
    auto ite = m_lstSocket.begin();
    while(ite !=m_lstSocket.end()){

           closesocket((*ite)->m_socket);
            WSACloseEvent((*ite)->m_olp.hEvent);
            delete (*ite);
        ite++;
    }
    m_lstSocket.clear();
    WSACleanup();
}

bool TCPServer::sendData(SOCKET sock, const char *szbuf, int nlen)
{
    if(!szbuf || nlen <=0)
        return false;
   //粘包
    //发送包大小
    if(send(sock,(char*)&nlen,sizeof(int),0)<=0)
        return false;
    //发送包内容
    if(send(sock,szbuf,nlen,0)<=0)
        return false;
    return true;
}

main.cpp

#include <QCoreApplication>
#include "network/tcpserver.h"
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    TCPServer ts;
    if(ts.initNetWork())
        printf("server is running......\n");
    else
        printf("server err\n");
    return a.exec();
}

五、优点

  1. 高效性：IOCP能够显著减少线程的使用，因为多个I/O操作可以共享少量的工作线程。这减少了线程上下文切换的开销，并提高了系统的可扩展性。
  2. 灵活性：IOCP允许应用程序根据需要动态地调整工作线程的数量，以适应不同的负载情况。
  3. 易用性：虽然IOCP的实现相对复杂，但一旦设置好，它可以为应用程序提供强大且灵活的异步I/O处理能力。

六、缺点

  1. 复杂性：IOCP的实现相对复杂，需要深入理解Windows的I/O模型和线程同步机制。
  2. 调试难度：由于IOCP的异步特性和多线程环境，调试和排查问题可能会比较困难。

七、应用场景

IOCP适用于需要处理大量并发I/O操作的应用程序，如高性能的Web服务器、数据库服务器、文件服务器等。它可以帮助这些应用程序提高吞吐量、降低延迟，并更好地利用系统资源。

爱编程的小猴
关注
专栏目录
什么是IO多路复用？其原理和用途是什么？
小橙子的笔记屋
08-01 671
IO多路复用
libevent源码分析之IO多路复用
游戏猫的博客
01-24 405
一、IO多路复用概念 IO多路复用是一种同步IO模型，实现一个线程可以监视多个文件句柄；一旦某个文件句柄就绪，就能够通知应用程序进行相应的读写操作；没有文件句柄就绪时会阻塞，挂起线程，直到阻塞超时。 二、libevent的IO多路复用应用 libevent支持多种IO多路复用机制，保障了跨平台和性能。支持的IO多路复用包括： 机制 平台 select unix、linux win32select win poll unix、linux epoll unix、linux kqu
IOCP使用
u010951692的专栏
10-15 782
昨天刚刚用IOCP写了一个xiaolizi
IOCP 实现的基本步骤
machuanfei_c的专栏
01-08 1737
回顾一下IOCP 是性能最好的一种I/O模型，它是应用程序用线程池处理异步I/O请求的一种机制。在处理多个并发的异步I/O请求时，以往的模型都是在接收请求是创建一个线程来应答请求。这样就有很多的线程并行地运行在系统中。而这些线程都是可运行的，Windows内核花费大量的时间在进行线程的上下文切换，并没有多少时间花在线程运行上。再加上创建线程的开销比较大，所以造成了效率的底下。 调用ioc
完成端口的一个例子
weixin_30847271的博客
10-09 144
来自微软的完成端口例子，就讲解一下它的使用套路吧 反正编程这个玩意，只要用过，自然就知道什么回事，一次不会再看一次，学习这个玩意，无他，勤奋而已。 奢谈效率等等，那只是孰能生巧上的功夫。 这个例子是在console下的例子,算是一个echo服务器吧, 跑起来后将在5150端口监听,一旦有个端口连接上来,发个数据给服务端口,它就echo回数据给那个端口.直到那个连接...
IO多路复用详解
氷的博客
05-30 2076
在IO多路复用模型中，引入了一种新的系统调用，查询IO的就绪状态。在Linux系统中，对应的系统调用为select/poll/epoll系统调用。通过该系统调用，一个进程可以监视多个文件描述符，一旦某个描述符就绪（一般是内核缓冲区可读/可写），内核能够将就绪的状态返回给应用程序。随后，应用程序根据就绪的状态，进行相应的IO系统调用。在IO多路复用模型中通过select/poll/epoll系统调用，单个应用程序的线程，可以不断地轮询成百上千的socket连接，当某个或者某些socket网络连接有IO就绪的状
Redis 网络模型 -- 阻塞非阻塞IO、IO多路复用、epoll详解
m0_71777195的博客
10-29 1423
当用户进程调用了select，那么整个进程会被阻塞，而同时，内核会"监视"所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从内核拷贝到用户进程。这个模型和阻塞IO的模型其实并没有太大的不同，事实上还更差一些。因为这里需要使用两个系统调用(select和recvfrom)，而阻塞IO只调用了一个系统调用(recvfrom)。但是，用select的优势在于它可以同时处理多个连接。
Java NIO - IO多路复用
Liarboy
09-28 3512
提供了非阻塞调用的方式，从操作系统层面解决了阻塞问题。将 socket 是否就绪检查逻辑下沉到操作系统层面，避免大量系统调用。告诉你有事件就绪，但是没告诉你具体是哪个 FD。epoll 直接将 fd 集合维护在内核中，通过红黑树来高效管理 fd 集合，同时维护一个就绪列表，当 fd 就绪后会添加到就绪列表中，当应用空间调用 epoll_wait 获取就绪事件时，内核直接判断就绪列表即可知道是否有事件就绪。
IO多路复用
兰枫
06-23 6381
IO多路复用 同步IO、异步IO、IO多路复用 IO两个阶段 IO过程分两阶段： 数据准备阶段。从设备读取数据到内核空间的缓冲区 内核空间复制回用户空间进程缓冲区阶段 发生IO的时候： 内核从IO设备读数据(例如：淘米，把米放在饭锅里煮饭) 进程从内核复制数据(盛饭，从内核这个饭锅里把饭装到碗里来) 系统调用----read函数 IO模型 同步IO模型包括阻塞IO、非阻塞IO、IO...
IOCP使用小结
blwinner的专栏
10-21 3845
很多知识，只有自己亲自实践了才知道坑在哪里。 socket是内核对象句柄，每次对socket执行操作，需要用户对象到内核对象的转换，执行完成返回结果，需要内核对象到用户对象的转换。 IOCP的中文名称是完成端口，目前是Windows下最高效的网络模型。特点：半异步，非阻塞。（我理解的完全异步是回调式，不需要人工参与，但是IOCP的异步需要轮询）。 其他模型的缺点： 1）se...
Windows下的IOCP模型（一）：介绍与简单使用
Summer_night_star的博客
10-16 1万+
一、IOCP简介 IOCP（I/O Completion Port，I/O完成端口）是Windows操作系统中伸缩性最好的一种I/O模型。     I/O完成端口是应用程序使用线程池处理异步I/O请求的一种机制。处理多个并发异步I/O请求时，使用I/O完成端口比在I/O请求时创建线程更快更高效。 二、IOCP的优势     I/O完成端口可以充分利用Windows内核来进行I/O调度，相较于传统的Winsock模型，IOCP在机制上有明显的优势。 模型 机制 特性 select模型 通过
IO 多路复用
热门推荐
ChineseSoftware的博客
03-29 3万+
一、简述 IO 多路复用是一种同步 IO 模型，实现一个线程可以监视多个文件句柄；一旦某个文件句柄就绪，就能够通知应用程序进行相应的读写操作；没有文件句柄就绪时会阻塞应用程序，交出 cpu。IO 是指网络 IO，多路指多个TCP连接(即 socket 或者 channel)，复用指复用一个或几个线程。意思说一个或一组线程处理多个 TCP 连接。最大优势是减少系统开销小，不必创建过多的进程/线程，也不必维护这些进程/线程。IO 多路复用的三种实现方式：select、poll、epoll。 二、select .
Windows下的IOCP模型（二）：IOCP使用示例
Summer_night_star的博客
01-10 2168
一 我对IOCP的使用     IOCP以异步处理网络I/O事件、优秀的线程调度等机制，成为Windows环境下性能最优秀的网络通信模型之一。但结合不同的应用场景，IOCP也需要合理的使用方式才能发挥其性能优势。     前段时间需要开发一个Windows环境下的网络通信综合集成系统，作者通过IOCP模型，设计实现了一个用于网络通信的底层模块，这个模块同时支持tcp、udp、广播、udp组播等多种通信方式，每种通信方式对应不同的事件处理机制，能够支持高性能的网络通信，并为上层模块提供服务。 二 支持多通信方
IOCP windows套接字使用完成端口
canlynetsky的博客
09-17 413
本文的代码源自《游戏服务端IOCP模型，自己封装的一个类，3行代码搞定服务端》，我改进过了，希望作者不要说我侵权，我声明这段代码是作者的劳动结晶，我只不过是在此基础上进行了些修改和调试。 windows里有如同Linux中的epoll一般强大的套接字管理功能，即socket编程模型。 我们面对服务器端编程时，往往希望一台主机能同时承接成千上万个客户端连接，只要我们的CPU和内存足够处理业务即可。但对于socket，如果使用select管理，在windows里有最多管理64个套接字的上限，毕竟都是依靠轮询来反
4.网络编程
最新发布
weixin_45476535的博客
09-14 461
程序注册端口：1024-49151。单个协议下，端口号不能冲突。公有端口0-1023。
描述windows下IO多路复用机制
05-31
需要注意的是，在Windows中，IO多路复用机制与Linux中的IO多路复用机制有些不同，主要体现在IOCP的使用上。IOCP需要创建一个独立的线程来处理IO完成事件，而且IOCP的使用需要一定的编程复杂度，需要针对具体应用场景...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱编程的小猴

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值