IOCP模型总结

最新推荐文章于 2024-08-05 23:24:03 发布
最新推荐文章于 2024-08-05 23:24:03 发布
阅读量454 收藏 1
点赞数
文章标签： socket 远程连接 io windows buffer winapi
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/angelz/article/details/6082042
版权

IOCP（I/O Completion Port，I/O完成端口）是性能最好的一种I/O模型。它是应用程序使用线程池处理异步I/O请求的一种机制。在处理多个并发的异步I/O请求时，以往的模型都是在接收请求是创建一个线程来应答请求。这样就有很多的线程并行地运行在系统中。而这些线程都是可运行的，Windows内核花费大量的时间在进行线程的上下文切换，并没有多少时间花在线程运行上。再加上创建新线程的开销比较大，所以造成了效率的低下。 

调用的步骤如下: 
抽象出一个完成端口大概的处理流程： 
1：创建一个完成端口。 
2：创建一个线程A。 
3：A线程循环调用GetQueuedCompletionStatus()函数来得到IO操作结果，这个函数是个阻塞函数。 
4：主线程循环里调用accept等待客户端连接上来。 
5：主线程里accept返回新连接建立以后，把这个新的套接字句柄用CreateIoCompletionPort关联到完成端口，然后发出一个异步的WSASend或者WSARecv调用，因为是异步函数，WSASend/WSARecv会马上返回，实际的发送或者接收数据的操作由WINDOWS系统去做。 
6：主线程继续下一次循环，阻塞在accept这里等待客户端连接。 
7：WINDOWS系统完成WSASend或者WSArecv的操作，把结果发到完成端口。 
8：A线程里的GetQueuedCompletionStatus()马上返回，并从完成端口取得刚完成的WSASend/WSARecv的结果。 
9：在A线程里对这些数据进行处理(如果处理过程很耗时，需要新开线程处理)，然后接着发出WSASend/WSARecv，并继续下一次循环阻塞在GetQueuedCompletionStatus()这里。 
归根到底概括完成端口模型一句话： 
我们不停地发出异步的WSASend/WSARecv IO操作，具体的IO处理过程由WINDOWS系统完成，WINDOWS系统完成实际的IO处理后，把结果送到完成端口上（如果有多个IO都完成了，那么就在完成端口那里排成一个队列）。我们在另外一个线程里从完成端口不断地取出IO操作结果，然后根据需要再发出WSASend/WSARecv IO操作。 

而IOCP模型是事先开好了N个线程，存储在线程池中，让他们hold。然后将所有用户的请求都投递到一个完成端口上，然后N个工作线程逐一地从完成端口中取得用户消息并加以处理。这样就避免了为每个用户开一个线程。既减少了线程资源，又提高了线程的利用率。 

完成端口模型是怎样实现的呢？我们先创建一个完成端口（::CreateIoCompletioPort()）。然后再创建一个或多个工作线程，并指定他们到这个完成端口上去读取数据。我们再将远程连接的套接字句柄关联到这个完成端口（还是用::CreateIoCompletionPort()）。一切就OK了。 

工作线程都干些什么呢？首先是调用::GetQueuedCompletionStatus()函数在关联到这个完成端口上的所有套接字上等待I/O的完成。再判断完成了什么类型的I/O。一般来说，有三种类型的I/O，OP_ACCEPT，OP_READ和OP_WIRTE。我们到数据缓冲区内读取数据后，再投递一个或是多个同类型的I/O即可（::AcceptEx()、::WSARecv()、::WSASend()）。对读取到的数据，我们可以按照自己的需要来进行相应的处理。 

为此，我们需要一个以OVERLAPPED（重叠I/O）结构为第一个字段的per-I/O数据自定义结构。 

typedef struct _PER_IO_DATA 
{ 
         OVERLAPPED ol;       // 重叠I/O结构 
         char buf[BUFFER_SIZE];   // 数据缓冲区 
         int nOperationType;         //I/O操作类型 
#define OP_READ 1 
#define OP_WRITE 2 
#define OP_ACCEPT 3 
} PER_IO_DATA, *PPER_IO_DATA; 

将一个PER_IO_DATA结构强制转化成一个OVERLAPPED结构传给::GetQueuedCompletionStatus()函数，返回的这个PER_IO_DATA结构的的nOperationType就是I/O操作的类型。当然，这些类型都是在投递I/O请求时自己设置的。 

这样一个IOCP服务器的框架就出来了。当然，要做一个好的IOCP服务器，还有考虑很多问题，如内存资源管理、接受连接的方法、恶意的客户连接、包的重排序等等。以上是个人对于IOCP模型的一些理解与看法，还有待完善。另外各Winsock API的用法参见MSDN。 


补充IOCP模型的实现： 

//创建一个完成端口 
HANDLE FCompletPort = CreateIoCompletionPort( INVALID_HANDLE_VALUE, 0,0,0 ); 

//接受远程连接，并把这个连接的socket句柄绑定到刚才创建的IOCP上 
AConnect = accept( FListenSock, addr, len); 
CreateIoCompletionPort( AConnect, FCompletPort, NULL, 0 ); 

//创建CPU数*2 + 2个线程 
SYSTEM_INFO si;
GetSystemInfo(&si);
for (int i=1;si.dwNumberOfProcessors*2+2;i++) 
{
   AThread = TRecvSendThread.Create( false ); 
   AThread.CompletPort = FCompletPort;//告诉这个线程，你要去这个IOCP去访问数据 
} 

OK，就这么简单，我们要做的就是建立一个IOCP，把远程连接的socket句柄绑定到刚才创建的IOCP上，最后创建n个线程，并告诉这n个线程到这个IOCP上去访问数据就可以了。 

再看一下TRecvSendThread线程都干些什么： 

void TRecvSendThread.Execute(...)
{
   while (!self.Terminated) 
   {
     //查询IOCP状态（数据读写操作是否完成） 
     GetQueuedCompletionStatus( CompletPort, BytesTransd, CompletKey, POVERLAPPED(pPerIoDat), TIME_OUT ); 

     if (BytesTransd !=0) ....... 
       ....;//数据读写操作完成 

     //再投递一个读数据请求 
     WSARecv( CompletKey, &(pPerIoDat->BufData), 1, BytesRecv, Flags, &(pPerIoDat->Overlap), NULL ); 
   }
} 

读写线程只是简单地检查IOCP是否完成了我们投递的读写操作，如果完成了则再投递一个新的读写请求。 
应该注意到，我们创建的所有TRecvSendThread都在访问同一个IOCP（因为我们只创建了一个IOCP），并且我们没有使用临界区！难道不会产生冲突吗？不用考虑同步问题吗？ 
呵呵，这正是IOCP的奥妙所在。IOCP不是一个普通的对象，不需要考虑线程安全问题。它会自动调配访问它的线程：如果某个socket上有一个线程A正在访问，那么线程B的访问请求会被分配到另外一个socket。这一切都是由系统自动调配的，我们无需过问。


ＩＯＣＰ相关代码下载：http://www.dssz.com/search.php?keyword=iocp

 

实例:

简单实现，适合IOCP入门
参考：《WINDOWS网络与通信程序设计》

 

 

/****************************************************************** 
* 
* Copyright (c) 2008, xxxxx有限公司 
* All rights reserved. 
* 
* 文件名称：IOCPHeader.h 
* 摘   要： IOCP定义文件 
* 
* 当前版本：1.0 
* 作    者：吴会然 
* 完成日期：2008-9-16 
* 
* 取代版本： 
* 原 作者： 
* 完成日期： 
* 
******************************************************************/

#ifndef _IOCPHEADER_H_20080916_ 
#define _IOCPHEADER_H_20080916_

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

#define BUFFER_SIZE 1024

/****************************************************************** 
* per_handle 数据 
*******************************************************************/ 
typedef struct _PER_HANDLE_DATA 
{ 
    SOCKET      s;      // 对应的套接字句柄 
    sockaddr_in addr;   // 对方的地址

}PER_HANDLE_DATA, *PPER_HANDLE_DATA;

/****************************************************************** 
* per_io 数据 
*******************************************************************/ 
typedef struct _PER_IO_DATA 
{ 
    OVERLAPPED ol;                 // 重叠结构 
    char        buf[BUFFER_SIZE];   // 数据缓冲区 
    int         nOperationType;     // 操作类型

#define OP_READ   1 
#define OP_WRITE 2 
#define OP_ACCEPT 3

}PER_IO_DATA, *PPER_IO_DATA;

#endif

/****************************************************************** 
* 
* Copyright (c) 2008, xxxxx有限公司 
* All rights reserved. 
* 
* 文件名称：main.cpp 
* 摘   要： iocp demo 
* 
* 当前版本：1.0 
* 作    者：吴会然 
* 完成日期：2008-9-16 
* 
* 取代版本： 
* 原 作者： 
* 完成日期： 
* 
******************************************************************/

#include <iostream> 
#include <string> 
#include "IOCPHeader.h" 
using namespace std;

DWORD WINAPI ServerThread( LPVOID lpParam );

int main( int argc, char *argv[] ) 
{ 
    //   
    WSADATA wsaData;

    if( 0 != WSAStartup( MAKEWORD( 2, 2 ), &wsaData ) ) 
    { 
        printf( "Using %s (Status:%s)/n", wsaData.szDescription, wsaData.szSystemStatus ); 
        printf( "with API versions: %d.%d to %d.%d", 
                 LOBYTE( wsaData.wVersion), HIBYTE( wsaData.wVersion ), 
                 LOBYTE( wsaData.wHighVersion), HIBYTE( wsaData.wHighVersion) );

        return -1; 
    } 
    else 
    { 
        printf("Windows sockets 2.2 startup/n"); 
    } 
    //

    int nPort = 20055;

    // 创建完成端口对象 
    // 创建工作线程处理完成端口对象的事件 
    HANDLE hIocp = ::CreateIoCompletionPort( INVALID_HANDLE_VALUE, 0, 0, 0 ); 
    ::CreateThread( NULL, 0, ServerThread, (LPVOID)hIocp, 0, 0 );

    // 创建监听套接字，绑定本地端口，开始监听 
    SOCKET sListen = ::socket( AF_INET,-SOCK_STREAM, 0 );

    SOCKADDR_IN addr; 
    addr.sin_family = AF_INET; 
    addr.sin_port = ::htons( nPort ); 
    addr.sin_addr.S_un.S_addr = INADDR_ANY; 
    ::bind( sListen, (sockaddr *)&addr, sizeof( addr ) ); 
    ::listen( sListen, 5 );

    printf( "iocp demo start....../n" );

    // 循环处理到来的请求 
    while ( TRUE ) 
    { 
        // 等待接受未决的连接请求 
        SOCKADDR_IN saRemote; 
        int nRemoteLen = sizeof( saRemote ); 
        SOCKET sRemote = ::accept( sListen, (sockaddr *)&saRemote, &nRemoteLen );

        // 接受到新连接之后，为它创建一个per_handle数据，并将他们关联到完成端口对象 
        PPER_HANDLE_DATA pPerHandle = ( PPER_HANDLE_DATA )::GlobalAlloc( GPTR, sizeof( PPER_HANDLE_DATA ) ); 
        if( pPerHandle == NULL ) 
        { 
            break; 
        }

        pPerHandle->s = sRemote; 
        memcpy( &pPerHandle->addr, &saRemote, nRemoteLen );

        ::CreateIoCompletionPort( ( HANDLE)pPerHandle->s, hIocp, (DWORD)pPerHandle, 0 );

        // 投递一个接受请求 
        PPER_IO_DATA pIoData = ( PPER_IO_DATA )::GlobalAlloc( GPTR, sizeof( PPER_IO_DATA ) ); 
        if( pIoData == NULL ) 
        { 
            break; 
        }

        pIoData->nOperationType = OP_READ; 
        WSABUF buf; 
        buf.buf = pIoData->buf; 
        buf.len = BUFFER_SIZE; 
         
        DWORD dwRecv = 0; 
        DWORD dwFlags = 0;

        ::WSARecv( pPerHandle->s, &buf, 1, &dwRecv, &dwFlags, &pIoData->ol, NULL );

    }

    // 
ERROR_PROC: 
    WSACleanup(); 
    //

    return 0; 
}

/****************************************************************** 
* 函数介绍：处理完成端口对象事件的线程 
* 输入参数： 
* 输出参数： 
* 返回值 ： 
*******************************************************************/ 
DWORD WINAPI ServerThread( LPVOID lpParam ) 
{ 
    HANDLE hIocp = ( HANDLE )lpParam; 
    if( hIocp == NULL ) 
    { 
        return -1; 
    }

    DWORD dwTrans = 0; 
    PPER_HANDLE_DATA pPerHandle; 
    PPER_IO_DATA     pPerIo; 
     
    while( TRUE ) 
    { 
        // 在关联到此完成端口的所有套接字上等待I/O完成 
        BOOL bRet = ::GetQueuedCompletionStatus( hIocp, &dwTrans, (LPDWORD)&pPerHandle, (LPOVERLAPPED*)&pPerIo, WSA_INFINITE ); 
        if( !bRet )     // 发生错误 
        { 
            ::closesocket( pPerHandle->s ); 
            ::GlobalFree( pPerHandle ); 
            ::GlobalFree( pPerIo );

            cout << "error" << endl; 
            continue; 
        }

        // 套接字被对方关闭 
        if( dwTrans == 0 && ( pPerIo->nOperationType == OP_READ || pPerIo->nOperationType&nb-sp;== OP_WRITE ) ) 
        { 
            ::closesocket( pPerHandle->s ); 
            ::GlobalFree( pPerHandle ); 
            ::GlobalFree( pPerIo );

            cout << "client closed" << endl; 
            continue; 
        }

        switch ( pPerIo->nOperationType ) 
        { 
        case OP_READ:       // 完成一个接收请求 
            { 
                pPerIo->buf[dwTrans] = '/0'; 
                printf( "%s/n", pPerIo->buf );

                // 继续投递接受操作 
                WSABUF buf; 
                buf.buf = pPerIo->buf; 
                buf.len = BUFFER_SIZE; 
                pPerIo->nOperationType = OP_READ; 
                 
                DWORD dwRecv = 0; 
                DWORD dwFlags = 0; 
                 
                ::WSARecv( pPerHandle->s, &buf, 1, &dwRecv, &dwFlags, &pPerIo->ol, NULL );

            } 
            break; 
        case OP_WRITE: 
        case OP_ACCEPT: 
            break;

        }

    }

    return 0; 
}

angelz
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot基础 第一天
2301_80034662的博客
08-05 306
Person类中利用ConfigurationProperties(prefix=" ")引入配置类中的元素 但是注意Person类中的类的名字必须与application.yaml中一致。如果不是标准的application.properties 是其他的Person类中需要用PropertySource来添加配置文件的路径。给容器中添加组件，将方法的返回值添加到容器中 容器中这个组件的默认ID就是方法名。的配置文件，我们自己编写的配置文件，也不能自动识别；的配置文件，让配置文件里面的内容生效；
Maven实战.插件
weixin_37799575的博客
07-31 567
除了内置绑定以外，用户还能够自己选择将某个插件目标绑定到生命周期的某个阶段上，这种自定义绑定方式能让 Maven 项目在构建过程中执行更多更富特色的任务。一个常见的例子是创建项目的源码 jar 包，内置的插件绑定关系中并没有涉及这一任务，因此需要用户自行配置。
Stream 33
2301_81744437的博客
08-02 199
【代码】Stream 33。
C#中的foreach和自定义比较
weixin_64532720的博客
08-05 792
在C#中，如果你想要使用自己定义的排序方式，你可以实现或IComparer接口，然后使用这个实现来自定义排序逻辑。以下是如何实现定义学生类set;set;​Age = age;实现 IComparer<Student> 接口// 根据年龄进行升序排序使用自定义比较器对集合进行排序​// 创建自定义比较器的实例​// 使用自定义比较器对集合进行排序如果你想要实现降序排序，可以在Compare// 根据年龄进行降序排序或者，你可以创建两个不同的比较器类，一个用于升序，一个用于降序。
【Python】列表元素排序：itertools.permutations()
持续更新中...
08-05 401
This tool returns successive r length permutations of elements in an iterable.If r is not specified or is None, then r defaults to the length of the iterable, and all possible full length permutations are generated.Permutations are printed in a lexicograph
07.FreeRTOS列表与列表项
L的博客
08-05 495
本文涉及FreeRTOS列表与列表项。包括列表和列表项的简介、列表相关API函数、代码验证。
C#学习笔记14：SYN6288语音模块_Winform上位机控制软件
NULL指向我的博客
08-05 575
今日尝试使用C# Winform写一个上位机软件控制 SYN6288语音模块 这里不讲什么基本原理(或者讲的比较略简)，直接讲实现了就...... 文章提供测试代码讲解、测试效果图、整体测试工程下载
fastjson-小于1.2.47绕过
无
08-02 1145
看第二个位置能否利用，是在loadClass里面，我们可以看到这个loadClass用法就是，在缓存中没找到的类加载时把这个类加进缓存中。可以看到loadClass的方法，被替换了，主要的安全逻辑就在替换的方法里，跟进看替换的方法。在上面分析时，我们也能注意到，在loadClass中有对传入类名的处理，对数组类进行处理，把。而MiscCodec的利用就是在加载默认的反序列化器时，Class的反序列化器也是它。所以绕过思路有了，我们先反序列化一个Class，它的值为恶意类，之后再反序列化恶意类。
STL—容器—list【list的介绍和基本使用】【list的迭代器失效问题】
aaa114514aaaa的博客
08-05 551
有关list的学习了解和基本接口的使用，能基本的使用list容器。分析了list迭代器失效的相关问题
C#中的list集合
weixin_64532720的博客
08-05 314
提供了一种灵活的方式来存储和管理一个对象数组，并且可以动态地增加和删除元素。是一个泛型集合类，它实现了。
链表的回文结构
zt3445164952的博客
08-05 72
1、寻找到到链表的中点，然后利用指针去改变里面存储的地址最后利用在最后的指针和一个在最前面的指针相比较就行了。对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。输入：1->2->2->1。给定一个链表的头指针。
创建一个简单的双链表
2305_78057683的博客
08-02 347
创建一个简单的双链表
GuLi商城-商品服务-API-新增商品-商品新增业务流程分析
最新发布
兴趣是最好的老师
08-05 24
【代码】GuLi商城-商品服务-API-新增商品-商品新增业务流程分析。
actual combat 44动态sql，crud模板
HSH541的博客
08-05 263
【代码】actual combat 44动态sql，crud模板。
【无标题】
qq_63688997的博客
08-05 506
首先定义了一个。
informer中DeltaFIFO机制的实现分析与源码解读
xsw164711368的博客
08-01 832
本文从源码层面介绍了DelasFIFO如何实现的。
SpringBoot原理解析（三）- Bean的属性注入方式
AHAO的博客
08-05 599
属性注入是指将需要注入的属性值设置到Bean实例中的操作。Bean的属性可以是基本类型、引用类型，甚至是其他Bean实例。属性注入通常是在对象创建过程中完成的，Spring容器会在Bean实例化之后，检查Bean定义中的注入配置，将配置的属性值注入到Bean中。通过属性注入，我们可以方便地将外部配置文件的值或其他Bean的引用注入到目标Bean中，从而实现组件之间的关联和依赖Spring提供了多种方式来进行Bean的属性注入，包括构造器注入、Setter方法注入、字段注入等。
Windows 常用命令集锦
AngelCryToo的专栏
07-29 404
Windows 操作系统提供了大量命令行工具，用于管理系统、执行任务和调试问题。本文将介绍 Windows 系统中最常用的命令，涵盖文件和目录管理、系统信息、网络管理、进程管理和磁盘管理等方面。
用uniapp 及socket.io做一个简单聊天app 撤回聊天及保留聊天记录 6
hzether的博客
08-05 176
以上是发送信息到websocket, 又将信息写入到数据库。我们用了一个sn,让记录保执唯一，以利于我们撤消。所以也要要求我们收到的信息也有这一个sn.注意这时我们加了一个time 为的是进行撤消判断。我们假设5分钟内可以撤消。withdraw表是撤消否，表示没有撤。canwithdraw是判断是不是可以取消聊天。
IOCP模型服务端c++代码
09-06
### 回答1： 下面是一个简单的基于IOCP模型的服务端C代码示例： ``` #include <stdio.h> #include <stdlib.h> #include <winsock2.h> #include <windows.h> #pragma comment(lib, "ws2_32.lib") #define MAX_CLIENTS 64 #define BUFFER_SIZE 4096 // 客户端数据结构 typedef struct _CLIENT { SOCKET socket; SOCKADDR_IN address; OVERLAPPED overlapped; WSABUF wsa_buffer; char buffer[BUFFER_SIZE]; } CLIENT, *PCLIENT; // IO操作类型 typedef enum _IO_OPERATION_TYPE { IO_READ, IO_WRITE } IO_OPERATION_TYPE, *PIO_OPERATION_TYPE; // IO操作数据结构 typedef struct _IO_OPERATION_DATA { IO_OPERATION_TYPE type; PCLIENT client; DWORD bytes_transferred; } IO_OPERATION_DATA, *PIO_OPERATION_DATA; HANDLE completion_port; // 完成端口句柄 PCLIENT clients[MAX_CLIENTS]; // 客户端数组 int client_count = 0; // 客户端计数器 // 添加客户端到客户端数组 void add_client(PCLIENT client) { int i; for (i = 0; i < MAX_CLIENTS; i++) { if (clients[i] == NULL) { clients[i] = client; client_count++; break; } } } // 从客户端数组中移除客户端 void remove_client(PCLIENT client) { int i; for (i = 0; i < MAX_CLIENTS; i++) { if (clients[i] == client) { clients[i] = NULL; client_count--; break; } } } // 异步读取客户端数据 void start_io_read(PCLIENT client) { DWORD flags = 0; IO_OPERATION_DATA* io_data = (IO_OPERATION_DATA*)malloc(sizeof(IO_OPERATION_DATA)); memset(&io_data->overlapped, 0, sizeof(OVERLAPPED)); io_data->type = IO_READ; io_data->client = client; io_data->bytes_transferred = 0; client->wsa_buffer.buf = client->buffer; client->wsa_buffer.len = BUFFER_SIZE; WSARecv(client->socket, &client->wsa_buffer, 1, &io_data->bytes_transferred, &flags, &io_data->overlapped, NULL); } // 异步写入数据到客户端 void start_io_write(PCLIENT client, char* buffer, int length) { DWORD flags = 0; IO_OPERATION_DATA* io_data = (IO_OPERATION_DATA*)malloc(sizeof(IO_OPERATION_DATA)); memset(&io_data->overlapped, 0, sizeof(OVERLAPPED)); io_data->type = IO_WRITE; io_data->client = client; io_data->bytes_transferred = 0; client->wsa_buffer.buf = buffer; client->wsa_buffer.len = length; WSASend(client->socket, &client->wsa_buffer, 1, &io_data->bytes_transferred, flags, &io_data->overlapped, NULL); } // 完成端口线程函数 DWORD WINAPI completion_port_thread(LPVOID lpParam) { PIO_OPERATION_DATA io_data; PCLIENT client; DWORD bytes_transferred; DWORD flags; while (TRUE) { if (GetQueuedCompletionStatus(completion_port, ### 回答2： IOCP（Input Output Completion Ports）模型是一种高效的异步IO模型，常用于高性能的服务器端开发。 下面是一个基于IOCP模型的服务端C代码的示例： ```c #include <stdio.h> #include <stdlib.h> #include <winsock2.h> #include <windows.h> #define MAX_CLIENTS 100 #define BUFFER_SIZE 1024 typedef struct { OVERLAPPED overlapped; SOCKET sock; WSABUF dataBuf; char buffer[BUFFER_SIZE]; DWORD bytesReceived; DWORD bytesSent; } PER_IO_DATA; DWORD WINAPI WorkerThread(LPVOID lpParam); int main() { WSADATA wsaData; SOCKET listenSock, clientSock; SOCKADDR_IN serverAddr, clientAddr; HANDLE hCompletionPort; DWORD numOfWorkerThreads; SYSTEM_INFO systemInfo; // Initialize Winsock if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) { printf("Failed to initialize winsock"); return 1; } // Create I/O completion port hCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0); // Get the number of available worker threads GetSystemInfo(&systemInfo); numOfWorkerThreads = systemInfo.dwNumberOfProcessors * 2; // Create worker threads for (int i = 0; i < numOfWorkerThreads; i++) { HANDLE hThread = CreateThread(NULL, 0, WorkerThread, hCompletionPort, 0, NULL); CloseHandle(hThread); } // Create listening socket listenSock = socket(AF_INET, SOCK_STREAM, 0); // Bind and listen serverAddr.sin_family = AF_INET; serverAddr.sin_addr.s_addr = htonl(INADDR_ANY); serverAddr.sin_port = htons(8888); bind(listenSock, (SOCKADDR*)&serverAddr, sizeof(serverAddr)); listen(listenSock, SOMAXCONN); // Accept incoming connections while (1) { int clientAddrSize = sizeof(clientAddr); clientSock = accept(listenSock, (SOCKADDR*)&clientAddr, &clientAddrSize); // Associate the client socket with the completion port CreateIoCompletionPort((HANDLE)clientSock, hCompletionPort, (DWORD)clientSock, 0); // Create IO operations structure PER_IO_DATA* perIOData = (PER_IO_DATA*)malloc(sizeof(PER_IO_DATA)); ZeroMemory(perIOData, sizeof(PER_IO_DATA)); perIOData->sock = clientSock; perIOData->dataBuf.len = BUFFER_SIZE; perIOData->dataBuf.buf = perIOData->buffer; // Start asynchronous receiving DWORD bytesReceived; if (WSARecv(clientSock, &(perIOData->dataBuf), 1, &bytesReceived, &(perIOData->flags), (LPOVERLAPPED)perIOData, NULL) == SOCKET_ERROR) { if (WSAGetLastError() != ERROR_IO_PENDING) { printf("Failed to start WSARecv: %d", WSAGetLastError()); closesocket(clientSock); free(perIOData); continue; } } } // Cleanup closesocket(listenSock); WSACleanup(); return 0; } DWORD WINAPI WorkerThread(LPVOID lpParam) { HANDLE hCompletionPort = (HANDLE)lpParam; DWORD bytesTransferred; PER_IO_DATA* perIOData; while (1) { // Get the next completed IO operation GetQueuedCompletionStatus(hCompletionPort, &bytesTransferred, (LPDWORD)&perIOData, (LPOVERLAPPED*)&perIOData, INFINITE); // Handle the completed IO operation if (bytesTransferred == 0) { // Client has disconnected closesocket(perIOData->sock); free(perIOData); continue; } // Process the received data // ... // Start asynchronous sending DWORD bytesSent; perIOData->bytesSent = bytesTransferred; if (WSASend(perIOData->sock, &(perIOData->dataBuf), 1, &bytesSent, 0, (LPOVERLAPPED)perIOData, NULL) == SOCKET_ERROR) { if (WSAGetLastError() != ERROR_IO_PENDING) { printf("Failed to start WSASend: %d", WSAGetLastError()); closesocket(perIOData->sock); free(perIOData); continue; } } // Start asynchronous receiving for the next data perIOData->dataBuf.len = BUFFER_SIZE; perIOData->dataBuf.buf = perIOData->buffer; DWORD bytesReceived; if (WSARecv(perIOData->sock, &(perIOData->dataBuf), 1, &bytesReceived, &(perIOData->flags), (LPOVERLAPPED)perIOData, NULL) == SOCKET_ERROR) { if (WSAGetLastError() != ERROR_IO_PENDING) { printf("Failed to start WSARecv: %d", WSAGetLastError()); closesocket(perIOData->sock); free(perIOData); continue; } } } return 0; } ``` 这个示例代码实现了一个使用IOCP模型的服务端，它首先初始化Winsock，并创建一个I/O完成端口。然后，它根据系统中可用的线程数量创建相应数量的工作线程。接下来，它创建一个监听套接字，并绑定到指定的端口上，然后开始接受客户端连接。对于每个连接，它会将客户端套接字与完成端口关联，并开始异步接收数据。在工作线程中，它通过GetQueuedCompletionStatus函数获取完成的I/O操作，然后根据操作类型进行相应的处理。在这个例子中，它处理接收到的数据，并通过异步发送响应。然后，它再次开始异步接收数据，以准备接收下一次请求。 这段代码基于Windows平台，使用了Winsock库来实现网络操作，通过WSARecv和WSASend函数来进行异步IO操作。每个I/O操作都使用了PER_IO_DATA结构体来保存相关的信息，并通过OVERLAPPED结构体进行异步操作的调度。主函数负责创建socket、绑定地址、监听连接等，然后将接受到的连接关联到完成端口并开启异步接收。 总结来说，IOCP模型通过异步IO操作和完成端口机制，能够高效处理并发的网络请求，提供了良好的可扩展性和性能。 ### 回答3： IOCP（Input/Output Completion Port）模型是一种高效的异步I/O处理模型，它在Windows平台上常用于服务端程序的开发。下面是一个用C语言实现的基本IOCP模型服务端代码，代码如下： ```c #include <stdio.h> #include <winsock2.h> #define MAX_CLIENTS 1000 // 定义一个自定义结构体用于保存每个客户端的信息 typedef struct { DWORD dwLastBytesRecv; // 上次接收的数据字节数 SOCKET socket; // 客户端套接字 // ... } CLIENT_INFO; int main() { WSADATA wsaData; if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) { printf("WSAStartup failed.\n"); return 1; } // 创建套接字 SOCKET listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (listenSocket == INVALID_SOCKET) { printf("Failed to create socket.\n"); WSACleanup(); return 1; } // 绑定套接字到本地地址和端口 sockaddr_in serverAddress; memset(&serverAddress, 0, sizeof(serverAddress)); serverAddress.sin_family = AF_INET; serverAddress.sin_addr.s_addr = htonl(INADDR_ANY); serverAddress.sin_port = htons(12345); if (bind(listenSocket, (sockaddr*)&serverAddress, sizeof(serverAddress)) == SOCKET_ERROR) { printf("Failed to bind socket.\n"); closesocket(listenSocket); WSACleanup(); return 1; } // 监听套接字 if (listen(listenSocket, SOMAXCONN) == SOCKET_ERROR) { printf("Failed to listen.\n"); closesocket(listenSocket); WSACleanup(); return 1; } // 创建完成端口 HANDLE hCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0); if (hCompletionPort == NULL) { printf("Failed to create completion port.\n"); closesocket(listenSocket); WSACleanup(); return 1; } // 关联监听套接字和完成端口 if (CreateIoCompletionPort((HANDLE)listenSocket, hCompletionPort, 0, 0) == NULL) { printf("Failed to create completion port association.\n"); CloseHandle(hCompletionPort); closesocket(listenSocket); WSACleanup(); return 1; } printf("Server started.\n"); // 循环接收客户端连接请求 while (1) { // 等待客户端连接 sockaddr_in clientAddress; int clientAddressSize = sizeof(clientAddress); SOCKET clientSocket = accept(listenSocket, (sockaddr*)&clientAddress, &clientAddressSize); if (clientSocket == INVALID_SOCKET) { printf("Failed to accept client.\n"); closesocket(listenSocket); CloseHandle(hCompletionPort); WSACleanup(); return 1; } // 将新连接的客户端套接字关联到完成端口 if (CreateIoCompletionPort((HANDLE)clientSocket, hCompletionPort, 0, 0) == NULL) { printf("Failed to create completion port association for client.\n"); closesocket(clientSocket); closesocket(listenSocket); CloseHandle(hCompletionPort); WSACleanup(); return 1; } // 创建客户端信息结构体并初始化 CLIENT_INFO* clientInfo = (CLIENT_INFO*)malloc(sizeof(CLIENT_INFO)); if (clientInfo == NULL) { printf("Failed to allocate memory for client info.\n"); closesocket(clientSocket); closesocket(listenSocket); CloseHandle(hCompletionPort); WSACleanup(); return 1; } clientInfo->dwLastBytesRecv = 0; clientInfo->socket = clientSocket; // 启动异步接收操作 DWORD dwBytesRecv; WSABUF dataBuff; dataBuff.buf = NULL; dataBuff.len = 0; DWORD dwFlags = 0; if (WSARecv(clientSocket, &dataBuff, 1, &dwBytesRecv, &dwFlags, NULL, NULL) == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING) { printf("Failed to start asynchronous receive.\n"); free(clientInfo); closesocket(clientSocket); closesocket(listenSocket); CloseHandle(hCompletionPort); WSACleanup(); return 1; } printf("New client connected.\n"); } // 清理资源 closesocket(listenSocket); CloseHandle(hCompletionPort); WSACleanup(); return 0; } ``` 这段代码实现了使用IOCP模型的服务端程序，包括创建监听套接字、绑定端口、监听连接、创建完成端口等操作。在接收到客户端连接请求后，将客户端套接字关联到完成端口上，并通过异步I/O的方式进行数据接收操作。 这只是一个基本的示例代码，实际应用中可能会有更多的功能和错误处理。需要注意的是，在使用这段代码时，需要在编译选项中加入 `-lws2_32` 参数，以链接 Windows Sockets 2 库。 希望以上回答对您有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值