《TCP/IP网络编程》学习笔记 | Chapter 23:IOCP

游戏服务器编程-iocp及封包处理 测试服务器:凑合着先用,就一个进程,没做分布式,界面是win32api做的很简易。 阅读详情

《TCP/IP网络编程》学习笔记 | Chapter 23:IOCP

通过重叠 I/O 理解 IOCP

epoll 和 IOCP 的性能比较

两种模型都很优秀,它们的差异主要在于操作系统内部的工作机制。

服务器端的响应时间和并发服务数是衡量服务器端好坏的重要因素。硬件性能和分配带宽充足情况下,若响应时间和并发服务数出了问题,查看以下两点:

  • 低效的 I/O 结构或低效的 CPU 使用
  • 数据库设计和查询语句(Query)的结构

实现非阻塞模式的套接字

前一章中只介绍了执行重叠 I/O 的 Sender 和 Receiver,但还未利用该模型实现过服务器端。因此,我们先利用重叠 I/O 模型实现回声服务器端。

首先介绍创建非阻塞模式套接字的方法。我们曾在第 17 章创建过非阻塞模式的套接字,与之类似,在 Windows 中通过如下函数调用将套接字属性改为非阻塞模式。

SOCKET hLisnSock;
int mode = 1;
.....
hListSock = WSASocket(PF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED); //创建重叠 IO
ioctlsocket(hLisnSock, FIONBIO, &mode); // 设定套接字为非阻塞属性
.....

ioctlsocket 函数负责控制套接字 I/O 方式,其调用具有如下含义:将 hLisnSock 句柄引用的套接字 I/O 模式(FIONBIO)改为变量 mode 中指定的形式。也就是说,FIONBIO 是用于更改套接字 I/O 模式的选项,该函数的第三个参数中传入的变量中若存有 0,则说明套接字是阻塞模式的;如果存有非 0 值,则说明已将套接字模式改为非阻塞模式。改为非阻塞模式后,除了以非阻塞模式进行 I/O 外,还具有如下特点:

  • 如果在没有客户端连接请求的状态下调用 accept 函数,将直接返回 INVALID_SOCKET。调用 WSAGetLastError 函数时返回 WSAEWOULDBLOCK。
  • 调用 accept 函数时创建的套接字同样具有非阻塞属性。

因此,针对非阻塞套接字调用 accept 函数并返回 INVALID_SOCKET 时,应该通过 WSAGetLastError 函数确认返回 INVALID_SOCKET 的理由,再进行适当处理。

以纯重叠 I/O 方式实现回声服务器端

由于代码量较大,我们分3个部分学习。

片段 1:main 函数之前

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>

#define BUF_SIZE 1024

void CALLBACK ReadCompRoutine(DWORD, DWORD, LPWSAOVERLAPPED, DWORD);
void CALLBACK WriteCompRoutine(DWORD, DWORD, LPWSAOVERLAPPED, DWORD);
void ErrorHandling(char *message);

typedef struct
{
    SOCKET hClntSock;   // 套接字句柄
    char buf[BUF_SIZE]; // 读写数据放置地址
    WSABUF wsaBuf;      // 指向放置读写的数据的地址和大小
} PER_IO_DATA, *LPPER_IO_DATA;

PER_IO_DATA 结构体中的信息足够进行数据交换。

片段 2:main 函数

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET hLisnSock, hRecvSock;
    SOCKADDR_IN lisnAdr, recvAdr;
    LPWSAOVERLAPPED lpOvLp;
    DWORD recvBytes, flagInfo = 0;
    LPPER_IO_DATA hbInfo;
    u_long mode = 1;
    int recvAdrsz;

    if (argc != 2)
    {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHandling("WSAStartup() error!");

    hLisnSock = WSASocket(PF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
    ioctlsocket(hLisnSock, FIONBIO, &mode);

    memset(&lisnAdr, 0, sizeof(lisnAdr));
    lisnAdr.sin_family = AF_INET;
    lisnAdr.sin_addr.s_addr = htonl(INADDR_ANY);
    lisnAdr.sin_port = htons(atoi(argv[1]));

    if (bind(hLisnSock, (SOCKADDR *)&lisnAdr, sizeof(lisnAdr)) == SOCKET_ERROR)
        ErrorHandling("bind() error");

    if (listen(hLisnSock, 5) == SOCKET_ERROR)
        ErrorHandling("listen() error");

    recvAdrsz = sizeof(recvAdr);
    while (1)
    {
        SleepEx(100, TRUE);

        hRecvSock = accept(hLisnSock, (SOCKADDR *)&recvAdr, &recvAdrsz);
        if (hRecvSock == INVALID_SOCKET)
        {
            if (WSAGetLastError() == WSAEWOULDBLOCK)
                continue;
            else
                ErrorHandling("accept() error");
        }

        puts("Client connected.....");
        lpOvLp = (LPWSAOVERLAPPED)malloc(sizeof(WSAOVERLAPPED));
        memset(lpOvLp, 0, sizeof(WSAOVERLAPPED));

        hbInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
        hbInfo->hClntSock = (DWORD)hRecvSock;
        (hbInfo->wsaBuf).buf = hbInfo->buf;
        (hbInfo->wsaBuf).len = BUF_SIZE;

        lpOvLp->hEvent = (HANDLE)hbInfo;
        WSARecv(hRecvSock, &(hbInfo->wsaBuf), 1, &recvBytes, &flagInfo, lpOvLp, ReadCompRoutine);
    }

    closesocket(hRecvSock);
    closesocket(hLisnSock);
    WSACleanup();
    return 0;
}

注意几点:

  • 之所以在循环内部申请 WSAOVERLAPPED 结构体空间,是因为每个客户端都需要独立的 WSAOVERLAPPED 结构体变量。
  • 基于 Completion Routine 函数的重叠 I/O 中不需要事件对象,因此,hEvent 中可以写入自定义结构体信息。
  • 调用 WSARecv 函数时将 ReadCompRoutine 函数指定为 Completion Routine。其
    中第六个参数 WSAOVERLAPPED 结构体变量地址值将传递到 Completion Routine 的第三个参数,因此,Completion Routine 函数内可以访问完成 I/O 的套接字句柄和缓冲。
  • 为了运行 Completion Routine 函数,循环调用 SleepEx 函数。

片段 3:2 个 Completion Routine 函数

void CALLBACK ReadCompRoutine(DWORD dwError, DWORD szRecvBytes, LPWSAOVERLAPPED lpOverlapped, DWORD flags)
{
    LPPER_IO_DATA hbInfo = (LPPER_IO_DATA)(lpOverlapped->hEvent);
    SOCKET hSock = hbInfo->hClntSock;
    LPWSABUF bufInfo = &(hbInfo->wsaBuf);
    DWORD sentBytes;

    if (szRecvBytes == 0)
    { // 如果接收到了 EOF 那么则关闭套接字以及释放对应的空间
        closesocket(hSock);
        free(lpOverlapped->hEvent);
        free(lpOverlapped);
        puts("Client disconnected.....");
    }
    else
    { // 如果不为零那么一定有需要回声的内容
        bufInfo->len = szRecvBytes;
        WSASend(hSock, bufInfo, 1, &sentBytes, 0, lpOverlapped, WriteCompRoutine);
    }
}

void CALLBACK WriteCompRoutine(DWORD dwError, DWORD szSendBytes, LPWSAOVERLAPPED lpOverlapped, DWORD flags)
{
    LPPER_IO_DATA hbInfo = (LPPER_IO_DATA)(lpOverlapped->hEvent);
    SOCKET hSock = hbInfo->hClntSock;
    LPWSABUF bufInfo = &(hbInfo->wsaBuf);
    DWORD recvBytes, flagInfo = 0;
    // 发送后默认等待再次回声
    WSARecv(hSock, bufInfo, 1, &recvBytes, &flagInfo, lpOverlapped, ReadCompRoutine);
}

void ErrorHandling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

实际的回声服务是通过这两个函数完成的。

上述示例的工作原理整理如下:

  • 有新的客户端连接时调用 WSARecv 函数,并以非阻塞模式接收数据,接收完成后调用 ReadCompRoutine 函数。
  • 调用 ReadCompRoutine 函数后调用 WSASend 函数,并以非阻塞模式发送数据,发送完成后
    调用 WriteCompRoutine 函数。
  • 此时调用的 WriteCompRoutine 函数将再次调用 WSARecv 函数,并以非阻塞模式等待接收数据。

通过交替调用 ReadCompRoutine 函数和 WriteCompRoutine 函数,反复执行数据的接收和发送操作。另外,每次增加 1 个客户端都会定义 PER_IO_DATA 结构体,以便将新创建的套接字句柄和缓冲信息传递给 ReadCompRoutine 函数和 WriteCompRoutine 函数。同时将该结构体地址值写入 WSAOVERLAPPED 结构体成员 hEvent,并传递给 Completion Routine 函数。这非常重要,可概括如下:“使用 WSAOVERLAPPED 结构体成员 hEvent 向完成 I/O 时自动调用的 Completion Routine 函数内部传递客户端信息(套接字和缓冲)。”

接下来需要验证运行结果,先要编写回声客户端,因为使用第 4 章的回声客户端会无法得到预想的结果。

重新实现客户端

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>

#define BUF_SIZE 1024

void ErrorHanding(const char *message);

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    SOCKET hSocket = socket(PF_INET, SOCK_STREAM, 0);
    if (hSocket == INVALID_SOCKET)
        ErrorHanding("socket() error!");

    int szAddr = sizeof(SOCKADDR_IN);

    SOCKADDR_IN servAddr;
    memset(&servAddr, 0, szAddr);
    servAddr.sin_family = AF_INET;
    servAddr.sin_addr.s_addr = inet_addr(argv[1]);
    servAddr.sin_port = htons(atoi(argv[2]));

    if (connect(hSocket, (SOCKADDR *)&servAddr, szAddr) == SOCKET_ERROR)
        ErrorHanding("connect() error!");
    else
        puts("Connected.......");

    while (1)
    {
        fputs("Input message(Q to quit): ", stdout);
        char message[BUF_SIZE] = {0};
        fgets(message, BUF_SIZE - 1, stdin);
        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;

        int strLen = strlen(message);
        send(hSocket, message, strLen, 0);
        int readLen = 0;
        while (1)
        {
            readLen += recv(hSocket, &message[readLen], BUF_SIZE - 1, 0);
            if (readLen >= strLen)
                break;
        }
        message[strLen] = '\0';
        printf("Message from server: %s\n", message);
    }

    closesocket(hSocket);
    WSACleanup();
    return 0;
}

void ErrorHanding(const char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

考虑到 TCP 的传输特性而重复调用了 recv 函数,直至接收完所有数据。

测试

编译:

gcc CmplRouEchoServ_win.c -lwsock32 -o CmplRouEchoServ
gcc StableEchoClnt_win.c -lws2_32 -o StableEchoClnt

运行结果:

在这里插入图片描述

从重叠 I/O 模型到 IOCP 模型

重叠 I/O 模型回声服务器端的缺点:重复调用非阻塞模式的 accept 函数和以进入 alertable wait 状态为目的的 SleepEx 函数将影响性能。

如果正确理解了之前的示例,应该不难发现这一点。既不能为了处理连接请求而只调用 accept 函数,也不能为了 Completion Routine 而只调用 SleepEx 函数,因此轮流调用了非阻塞模式的 accept 函数和 SleepEx 函数(设置较短的超时时间)。这个恰恰是影响性能的代码结构。

这属于重叠I/O结构固有的缺陷。

可以考虑如下方法:让 main 线程(在 main 函数内部)调用 accept 函数,再单独创建 1 个线程负责客户端 I/O。

其实这就是 IOCP 中采用的服务器端模型。换言之,IOCP 将创建专用的 I/O 线程,该线程负责与所有客户端进行I/O。

分阶段实现 IOCP 程序

本节我们编写最后一种服务器模型 IOCP,比阅读代码更重要的是理解 IOCP 本身。

IOCP 关注焦点:

  • I/O 是否以非阻塞模式工作?
  • 如何确定非阻塞模式的 I/O 是否完成?

创建“完成端口"

IOCP 中已完成的 I/O 信息将注册到完成端口对象(Completion Port,简称 CP 对象),但这个过
程并非单纯的注册,首先需要经过如下请求过程:“该套接字的 I/O 完成时,请把状态信息注册到指定 CP 对象。"

该过程称为“套接字和CP对象之间的连接请求”。因此,为了实现基于 IOCP 模型的服务器端,需要做如下 2 项工作。

  • 创建完成端口对象。
  • 建立完成端口对象和套接字之间的联系。

此时的套接字必须被赋予重叠属性。上述 2 项工作可以通过 1 个函数完成,但为了创建 CP 对象,先介绍如下函数。

#include <windows.h>

HANDLE CreateIoCompletionport(
	HANDLE FileHandle,
	HANDLE ExistingCompletionPort,
	ULONG_PTR Completionkey,
	DWORD NumberofConcurrentThreads
);

参数:

  • FileHandle:创建 CP 对象时传递 INVALID_HANDLE_VALUE。
  • ExistingCompletionPort:创建 CP 对象时传递 NULL。
  • CompletionKey:创建 CP 对象时传递 0。
  • NumberOfConcurrentThreads:分配给 CP 对象的用于处理 I/O 的线程数。例如,该参数为 2 时,说明分配给 CP 对象的可以同时运行的线程数最多为 2 个;如果该参数为 0,系统中 CPU 个数(内核数)就是可同时运行的最大线程数。

成功时返回 CP 对象句柄,失败时返回 NULL。

以创建 CP 对象为目的调用上述函数时,只有最后一个参数才真正具有含义。可以用如下代码段将分配给 CP 对象的用于处理 I/O 的线程数指定为 2。

HANDLE hCpObject;
.....
hCpObject = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 2);

连接完成端口对象和套接字

既然有了 CP 对象,接下来就要将该对象连接到套接字,只有这样才能使已完成的套接字 I/O 信息注册到 CP 对象。下面以建立连接为目的再次介绍 CreateIoCompletionPort 函数。

#include <windows.h>

HANDLE CreateIoCompletionport(
	HANDLE FileHandle,
	HANDLE ExistingCompletionPort,
	ULONG_PTR Completionkey,
	DWORD NumberofConcurrentThreads
);

参数:

  • FileHandle:要连接到 CP 对象的套接字句柄。
  • ExistingCompletionPort:要连接套接字的 CP 对象句柄。
  • CompletionKey:传递已完成 I/O 相关信息,关于该参数将在稍后介绍的 GetQueuedCompletionStatus 函数中共同讨论。
  • NumberOfConcurrentThreads:无论传递何值,只要该函数的第二个参数非 NULL 就会忽略。

成功时返回 CP 对象句柄,失败时返回 NULL。

上述函数的第二种功能就是将 FileHandle 句柄指向的套接字和 ExistingCompletionPort 指向的 CP 对象相连。该函数的调用方式如下:

HANDLE hCpObject;
SOCKET hSock;
......
CreateIoCompletionPort((HANDLE)hSock, hCpObject, (DWORD)ioInfo, 0);

调用 CreateIoCompletionPort 函数后,只要针对 hSock 的 I/O 完成,相关信息就将注册到 hCpObject 指向的 CP 对象。

确认完成端口已完成的 I/O 和线程的 I/O 处理

我们已经掌握了 CP 对象的创建及其与套接字建立连接的方法,接下来就要学习如何确认 CP 中注册的已完成的 I/O。完成该功能的函数如下。

#include <windows.h>

BOOL GetQueuedCompletionStatus(
	HANDLE CompletionPort,
	LPDWORD lpNumberOfBytes,
	PULONG_PTR lpCompletionKey,
	LPOVERLAPPED * lpoverlapped,
	DWORD dwMilliseconds
);

参数:

  • CompletionPort:注册有已完成 I/O 信息的CP对象句柄。
  • IpNumberOfBytes:用于保存 I/O 过程中传输的数据大小的变量地址值。
  • IpCompletionKey:用于保存 CreateIoCompletionPort 函数的第三个参数值的变量地址值。
  • IpOverlapped:用于保存调用 WSASend、WSARecv 函数时传递的 OVERLAPPED 结构体地址的变量地址值。
  • dwMilliseconds:超时信息超过该指定时间后将返回FALSE并跳出函数。传递 INFINITE 时,程序将阻塞,直到已完成 I/O 信息写入 CP 对象。

成功时返回 TRUE,失败时返回 FALSE。

虽然只介绍了 2 个 IOCP 相关函数,但依然有些复杂,特别是上述函数的第三个和第四个参数更是如此。其实这 2 个参数主要是为了获取需要的信息而设置的,下面介绍这 2 种信息的含义。

  • 通过 GetQueuedCompletionStatus 函数的第三个参数得到的是以连接套接字和 CP 对象为目的而调用的 CreateloCompletionPort 函数的第三个参数值。
  • 通过 GetQueueCompletionStatus 函数的第四个参数得到的是调用 WSASend、WSARecv 函数时传入的 WSAOVERLAPPED 结构体变量地址值。

IOCP 中将创建全职 I/O 线程,由该线程针对所有客户端进行 I/O。程序员自行创建调用 WSASend、WSARecv 等 I/O 函数的线程,该线程为了确认 I/O 的完成会调用 GetQueuedCompletionStatus 函数。

虽然任何线程都能调用 GetQueuedCompletionStatus 函数,但实际得到 I/O 完成信息的线程数不会超过调用 CreateIoCompletionPort 函数时指定的最大线程数。

实现基于 IOCP 的回声服务器端

同样分段进行讲解。

片段 1:main 函数之前

#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <winsock2.h>
#include <windows.h>

#define BUF_SIZE 100
#define READ 3
#define WRITE 5

typedef struct // socket info
{
    SOCKET hClntSock;
    SOCKADDR_IN clntAdr;
} PER_HANDLE_DATA, *LPPER_HANDLE_DATA;

typedef struct // buffer info
{
    OVERLAPPED overlapped;
    WSABUF wsaBuf;
    char buffer[BUF_SIZE];
    int rwMode; // READ or WRITE
} PER_IO_DATA, *LPPER_IO_DATA;

DWORD WINAPI EchoThreadMain(LPVOID CompletionPortIo);
void ErrorHandling(char *message);

其中,PER_HANDLE_DATA 是保存与客户端相连套接字的结构体。将 I/O 中使用的缓冲和重叠 I/O 中需要的 OVERLAPPED 结构体变量封装到同一结构体中进行定义。

片段 2:main 函数

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    HANDLE hComPort;
    SYSTEM_INFO sysInfo;
    LPPER_IO_DATA ioInfo;
    LPPER_HANDLE_DATA handleInfo;

    SOCKET hServSock;
    SOCKADDR_IN servAdr;
    DWORD recvBytes, flags = 0;

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHandling("WSAStartup() error!");

    hComPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0); // 创建 CP 对象
    GetSystemInfo(&sysInfo);                                             // 获得当前系统的信息
    // 创建线程数等于 CPU 数量
    for (int i = 0; i < sysInfo.dwNumberOfProcessors; i++)
        _beginthreadex(NULL, 0, (LPVOID)EchoThreadMain, (LPVOID)hComPort, 0, NULL);

    hServSock = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
    memset(&servAdr, 0, sizeof(servAdr));
    servAdr.sin_family = AF_INET;
    servAdr.sin_addr.s_addr = htonl(INADDR_ANY);
    servAdr.sin_port = htons(atoi(argv[1]));

    if (bind(hServSock, (SOCKADDR *)&servAdr, sizeof(servAdr)) == SOCKET_ERROR)
        ErrorHandling("bind() error");
    if (listen(hServSock, 5) == SOCKET_ERROR)
        ErrorHandling("listen() error");

    while (1)
    {
        SOCKET hClntSock;
        SOCKADDR_IN clntAdr;
        int addrLen = sizeof(clntAdr);

        hClntSock = accept(hServSock, (SOCKADDR *)&clntAdr, &addrLen);
        if (hClntSock == INVALID_SOCKET)
        {
            if (WSAGetLastError() == WSAEWOULDBLOCK)
                continue;
            else
                ErrorHandling("accept() error");
        }

        handleInfo = (LPPER_HANDLE_DATA)malloc(sizeof(PER_HANDLE_DATA));
        handleInfo->hClntSock = hClntSock;
        memcpy(&(handleInfo->clntAdr), &clntAdr, addrLen);

        CreateIoCompletionPort((HANDLE)hClntSock, hComPort, (ULONG_PTR)handleInfo, 0); // 建立连接

        ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
        memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
        ioInfo->wsaBuf.len = BUF_SIZE;
        ioInfo->wsaBuf.buf = ioInfo->buffer;
        ioInfo->rwMode = READ;

        WSARecv(handleInfo->hClntSock, &(ioInfo->wsaBuf), 1, &recvBytes, &flags, &(ioInfo->overlapped), NULL);
    }

    closesocket(hServSock);
    WSACleanup();
    return 0;
}

套接字的重叠 I/O 完成时,已完成信息将写入连接的 CP 对象,这会引起 GetQueuedCompletionStatus 函数的返回。请注意观察 handleInfo,它同样是在 GetQueuedCompletionStatus 函数返回时得到的。

IOCP 本身不会帮我们区分输入完成和输出完成的状态。无论输入还是输出,只通知完成 I/O 的状态,因此需要通过额外的变量区分这 2 种 I/O。PER_IO_DATA 结构体中的 rwMode 就用于完成该功能。

WSARecv 函数的第七个参数为 OVERLAPPED 结构体变量地址值,该值也可以在 GetQueuedCompletionStatus 函数返回时得到。

片段 3:线程的 main 函数

DWORD WINAPI EchoThreadMain(LPVOID pComPort)
{
    HANDLE hComPort = (HANDLE)pComPort;
    SOCKET sock;
    DWORD bytesTrans;
    LPPER_HANDLE_DATA handleInfo;
    LPPER_IO_DATA ioInfo;
    DWORD flags = 0;

    while (1)
    {
        GetQueuedCompletionStatus(hComPort, &bytesTrans, (PULONG_PTR)&handleInfo, (LPOVERLAPPED *)&ioInfo, INFINITE);
 
        sock = handleInfo->hClntSock;

        if (ioInfo->rwMode == READ)
        {
            puts("message received!");
            if (bytesTrans == 0)
            { // 传输 EOF 时
                closesocket(sock);
                free(handleInfo);
                free(ioInfo);
                continue;
            }

            memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
            ioInfo->wsaBuf.len = bytesTrans;
            ioInfo->rwMode = WRITE;

            WSASend(sock, &(ioInfo->wsaBuf), 1, NULL, 0, &(ioInfo->overlapped), NULL);

            ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
            memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
            ioInfo->wsaBuf.len = BUF_SIZE;
            ioInfo->wsaBuf.buf = ioInfo->buffer;
            ioInfo->rwMode = READ;

            WSARecv(sock, &(ioInfo->wsaBuf), 1, NULL, &flags, &(ioInfo->overlapped), NULL);
        }
        else
        {
            puts("message sent!");
            free(ioInfo);
        }
    }
    return 0;
}

void ErrorHandling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

指针 iolnfo 中保存的既是 OVERLAPPED 结构体变量地址值,也是 PER_IO_DATA 结构体变量地址值。因此,可以通过检查 rwMode 成员中的值判断是输入完成还是输出完成。

完整程序:

#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <winsock2.h>
#include <windows.h>

#define BUF_SIZE 100
#define READ 3
#define WRITE 5

typedef struct // socket info
{
    SOCKET hClntSock;
    SOCKADDR_IN clntAdr;
} PER_HANDLE_DATA, *LPPER_HANDLE_DATA;

typedef struct // buffer info
{
    OVERLAPPED overlapped;
    WSABUF wsaBuf;
    char buffer[BUF_SIZE];
    int rwMode; // READ or WRITE
} PER_IO_DATA, *LPPER_IO_DATA;

DWORD WINAPI EchoThreadMain(LPVOID CompletionPortIo);
void ErrorHandling(char *message);

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    HANDLE hComPort;
    SYSTEM_INFO sysInfo;
    LPPER_IO_DATA ioInfo;
    LPPER_HANDLE_DATA handleInfo;

    SOCKET hServSock;
    SOCKADDR_IN servAdr;
    DWORD recvBytes, flags = 0;

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHandling("WSAStartup() error!");

    hComPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0); // 创建 CP 对象
    GetSystemInfo(&sysInfo);                                             // 获得当前系统的信息
    // 创建线程数等于 CPU 数量
    for (int i = 0; i < sysInfo.dwNumberOfProcessors; i++)
        _beginthreadex(NULL, 0, (LPVOID)EchoThreadMain, (LPVOID)hComPort, 0, NULL);

    hServSock = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
    memset(&servAdr, 0, sizeof(servAdr));
    servAdr.sin_family = AF_INET;
    servAdr.sin_addr.s_addr = htonl(INADDR_ANY);
    servAdr.sin_port = htons(atoi(argv[1]));

    if (bind(hServSock, (SOCKADDR *)&servAdr, sizeof(servAdr)) == SOCKET_ERROR)
        ErrorHandling("bind() error");
    if (listen(hServSock, 5) == SOCKET_ERROR)
        ErrorHandling("listen() error");

    while (1)
    {
        SOCKET hClntSock;
        SOCKADDR_IN clntAdr;
        int addrLen = sizeof(clntAdr);

        hClntSock = accept(hServSock, (SOCKADDR *)&clntAdr, &addrLen);
        if (hClntSock == INVALID_SOCKET)
        {
            if (WSAGetLastError() == WSAEWOULDBLOCK)
                continue;
            else
                ErrorHandling("accept() error");
        }

        handleInfo = (LPPER_HANDLE_DATA)malloc(sizeof(PER_HANDLE_DATA));
        handleInfo->hClntSock = hClntSock;
        memcpy(&(handleInfo->clntAdr), &clntAdr, addrLen);

        CreateIoCompletionPort((HANDLE)hClntSock, hComPort, (ULONG_PTR)handleInfo, 0); // 建立连接

        ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
        memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
        ioInfo->wsaBuf.len = BUF_SIZE;
        ioInfo->wsaBuf.buf = ioInfo->buffer;
        ioInfo->rwMode = READ;

        WSARecv(handleInfo->hClntSock, &(ioInfo->wsaBuf), 1, &recvBytes, &flags, &(ioInfo->overlapped), NULL);
    }

    closesocket(hServSock);
    WSACleanup();
    return 0;
}

DWORD WINAPI EchoThreadMain(LPVOID pComPort)
{
    HANDLE hComPort = (HANDLE)pComPort;
    SOCKET sock;
    DWORD bytesTrans;
    LPPER_HANDLE_DATA handleInfo;
    LPPER_IO_DATA ioInfo;
    DWORD flags = 0;

    while (1)
    {
        GetQueuedCompletionStatus(hComPort, &bytesTrans, (PULONG_PTR)&handleInfo, (LPOVERLAPPED *)&ioInfo, INFINITE);
 
        sock = handleInfo->hClntSock;

        if (ioInfo->rwMode == READ)
        {
            puts("message received!");
            if (bytesTrans == 0)
            { // 传输 EOF 时
                closesocket(sock);
                free(handleInfo);
                free(ioInfo);
                continue;
            }

            memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
            ioInfo->wsaBuf.len = bytesTrans;
            ioInfo->rwMode = WRITE;

            WSASend(sock, &(ioInfo->wsaBuf), 1, NULL, 0, &(ioInfo->overlapped), NULL);

            ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
            memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
            ioInfo->wsaBuf.len = BUF_SIZE;
            ioInfo->wsaBuf.buf = ioInfo->buffer;
            ioInfo->rwMode = READ;

            WSARecv(sock, &(ioInfo->wsaBuf), 1, NULL, &flags, &(ioInfo->overlapped), NULL);
        }
        else
        {
            puts("message sent!");
            free(ioInfo);
        }
    }
    return 0;
}

void ErrorHandling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

编译:

gcc IOCPEchoServ_win.c -lws2_32 -o IOCPEchoServ

运行结果:

在这里插入图片描述

IOCP 性能更优的原因

  1. 因为是非阻塞模式的 I/O,所以不会由 I/O 引发延迟。
  2. 查找已完成I/O时无需添加循环。
  3. 无需将作为 I/O 对象的套接字句柄保存到数组进行管理。
  4. 可以调整处理 I/O 的线程数,所以可在实验数据的基础上选用合适的线程数。

IOCP 是 Windows 特有的功能,所以很大程度上要归功于操作系统。

习题

(1)完成端口对象将分配多个线程用于处理 I/O。如何创建这些线程?如何分配?请从源代码级别进行说明。

首先使用 CreateIoCompletionPort 函数创建 IOCP 对象:

HANDLE hCompletionPort = CreateIoCompletionPort(
    INVALID_HANDLE_VALUE,  // 首次创建时使用此参数
    NULL,                  
    0,                     // 初始线程数(实际忽略)
    0                      // 并发线程数(通常为 CPU 核心数)
);

然后将 FileHandle 句柄指向的套接字和 CP 对象相连:

HANDLE hDevice = CreateFile(...); // 或 socket()
CreateIoCompletionPort(
    hDevice,           // 要关联的句柄
    hCompletionPort,   // 目标 IOCP
    (ULONG_PTR)key,    // 自定义标识(如会话上下文)
    0                  // 并发线程数(继承 IOCP 的设置)
);

调用 CreateIoCompletionPort 函数后,只要针对 hSock 的 I/O 完成,相关信息就将注册到 hCpObject 指向的 CP 对象。

每个线程调用 GetQueuedCompletionStatus 等待 I/O 事件:

DWORD WINAPI WorkerThreadFunction(LPVOID lpParam) {
    HANDLE hCompletionPort = (HANDLE)lpParam;
    DWORD dwBytesTransferred;
    ULONG_PTR completionKey;
    LPOVERLAPPED pOverlapped;

    while (true) {
        BOOL status = GetQueuedCompletionStatus(
            hCompletionPort,
            &dwBytesTransferred,
            &completionKey,
            &pOverlapped,
            INFINITE          // 无限等待事件
        );

        if (!status) {
            // 处理错误或连接关闭
            if (pOverlapped == NULL) break; // 收到退出信号
            DWORD err = GetLastError();
            HandleError(err);
            continue;
        }

        // 处理完成事件
        HandleIOCompletion(completionKey, dwBytesTransferred, pOverlapped);
    }
    return 0;
}

(2)CreateIoCompletionPort 函数与其他函数不同,提供 2 种功能。请问是哪 2 种?

  • 创建“完成端口”对象。
  • 建立“完成端口”对象和套接字之间的联系。

(3)完成端口对象和套接字之间的连接意味着什么?如何连接?

意味着将已完成的套接字 I/O 信息注册到 CP 对象,使得该套接字上发生的异步操作(如读写操作)的完成事件能够通过完成端口机制进行通知和调度。通过CreateIoCompletionPort 函数实现。

下面以建立连接为目的再次介绍 CreateIoCompletionPort 函数。

#include <windows.h>

HANDLE CreateIoCompletionport(
	HANDLE FileHandle,
	HANDLE ExistingCompletionPort,
	ULONG_PTR Completionkey,
	DWORD NumberofConcurrentThreads
);

参数:

  • FileHandle:要连接到 CP 对象的套接字句柄。
  • ExistingCompletionPort:要连接套接字的 CP 对象句柄。
  • CompletionKey:传递已完成 I/O 相关信息,关于该参数将在稍后介绍的 GetQueuedCompletionStatus 函数中共同讨论。
  • NumberOfConcurrentThreads:无论传递何值,只要该函数的第二个参数非 NULL 就会忽略。

成功时返回 CP 对象句柄,失败时返回 NULL。

该函数的调用方式如下:

HANDLE hCpObject;
SOCKET hSock;
......
CreateIoCompletionPort((HANDLE)hSock, hCpObject, (DWORD)ioInfo, 0);

调用 CreateIoCompletionPort 函数后,只要针对 hSock 的 I/O 完成,相关信息就将注册到 hCpObject 指向的 CP 对象。

(4)下列关于 IOCP 的说法错误的是?

a. 以最少的线程处理多数 I/O 的结构,因此可以减少上下文切换引起的性能低下。
b. 执行 I/O 的过程中,服务器端无需等待I/O完成,可以执行其他任务,故能提高 CPU 效率。
c. I/O 完成时会自动调用相关 Completion Routine 函数,因此没必要调用特定函数以等待 I/O 完成。
d. 除 Windows 外,其他操作系统同样支持 IOCP,所以这种模型具有良好的移植性。

答:

c、d。

(5)判断下列关于 IOCP 中选择合理线程数的方法是否合适。

  • 通常会选择与 CPU 数同样数量的线程。(√)
  • 最好在条件允许的范围内通过实验决定线程数。(√)
  • 分配的线程数越多越好。例如,1 个线程就足够多的情况下应该多分配几个,比如创建 3 个线程分配给 IOCP。(×)

(6)利用本章的 IOCP 模型实现聊天服务器端,该聊天服务器端应当结合第 20 章的聊天客户端 chat_clnt_win.c 正常运行。编写程序时不必刻意套用本章 IOCP 示例中的框架,那样反而会加大实现难度。

服务器端代码:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <process.h>
#include <winsock2.h>
#include <windows.h>

#define BUF_SIZE 120
#define MAX_CLNT 256
#define READ 3
#define WRITE 5

typedef struct // socket info
{
    SOCKET hClntSock;
    SOCKADDR_IN clntAdr;
    char name[20];
} PER_CLIENT_INFO, *LPPER_CLIENT_INFO;

typedef struct // buffer info
{
    OVERLAPPED overlapped;
    WSABUF wsaBuf;
    char buffer[BUF_SIZE];
    int rwMode; // READ or WRITE
} PER_IO_DATA, *LPPER_IO_DATA;

DWORD WINAPI WorkerThread(LPVOID pComPort);
void SendMsg(char *msg, int len);
void ErrorHandling(char *msg);

int clntCnt = 0;
PER_CLIENT_INFO clntSocks[MAX_CLNT];
HANDLE hMutex;

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    HANDLE hComPort;
    SYSTEM_INFO sysInfo;
    LPPER_IO_DATA ioInfo;
    LPPER_CLIENT_INFO clntInfo;

    SOCKET hServSock;
    SOCKADDR_IN servAdr;
    DWORD recvBytes, flags = 0;

    if (argc != 2)
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHandling("WSAStartup() error!");

    hMutex = CreateMutex(NULL, FALSE, NULL);
    // 创建 CP 对象
    hComPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
    // 获得当前系统的信息
    GetSystemInfo(&sysInfo);
    // 创建线程数等于 CPU 数量
    for (int i = 0; i < sysInfo.dwNumberOfProcessors; i++)
        _beginthreadex(NULL, 0, (LPVOID)WorkerThread, (LPVOID)hComPort, 0, NULL);

    hServSock = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
    memset(&servAdr, 0, sizeof(servAdr));
    servAdr.sin_family = AF_INET;
    servAdr.sin_addr.s_addr = htonl(INADDR_ANY);
    servAdr.sin_port = htons(atoi(argv[1]));

    if (bind(hServSock, (SOCKADDR *)&servAdr, sizeof(servAdr)) == SOCKET_ERROR)
        ErrorHandling("bind() error");
    if (listen(hServSock, 5) == SOCKET_ERROR)
        ErrorHandling("listen() error");

    // 接受客户端连接
    while (1)
    {
        SOCKET hClntSock;
        SOCKADDR_IN clntAdr;
        int addrLen = sizeof(clntAdr);

        hClntSock = accept(hServSock, (SOCKADDR *)&clntAdr, &addrLen);
        if (hClntSock == INVALID_SOCKET)
        {
            if (WSAGetLastError() == WSAEWOULDBLOCK)
                continue;
            else
                ErrorHandling("accept() error");
        }

        WaitForSingleObject(hMutex, INFINITE);
        clntSocks[clntCnt++].hClntSock = hClntSock;
        ReleaseMutex(hMutex);

        clntInfo = (LPPER_CLIENT_INFO)malloc(sizeof(PER_CLIENT_INFO));
        clntInfo->hClntSock = hClntSock;
        memcpy(&(clntInfo->clntAdr), &clntAdr, addrLen);

        CreateIoCompletionPort((HANDLE)hClntSock, hComPort, (ULONG_PTR)clntInfo, 0); // 建立连接

        ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
        memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
        ioInfo->wsaBuf.len = BUF_SIZE;
        ioInfo->wsaBuf.buf = ioInfo->buffer;
        ioInfo->rwMode = READ;

        WSARecv(clntInfo->hClntSock, &(ioInfo->wsaBuf), 1, &recvBytes, &flags, &(ioInfo->overlapped), NULL);
    }

    closesocket(hServSock);
    WSACleanup();

    return 0;
}

DWORD WINAPI WorkerThread(LPVOID pComPort)
{
    HANDLE hComPort = (HANDLE)pComPort;
    SOCKET sock;
    DWORD bytesTrans;
    LPPER_CLIENT_INFO clntInfo;
    LPPER_IO_DATA ioInfo;
    DWORD flags = 0;

    while (1)
    {
        GetQueuedCompletionStatus(hComPort, &bytesTrans, (PULONG_PTR)&clntInfo, (LPOVERLAPPED *)&ioInfo, INFINITE);

        sock = clntInfo->hClntSock;

        if (ioInfo->rwMode == READ)
        {
            if (bytesTrans == 0)
            { // 传输 EOF 时
                closesocket(sock);
                free(clntInfo);
                free(ioInfo);
                continue;
            }

            memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
            ioInfo->wsaBuf.len = bytesTrans;
            ioInfo->rwMode = WRITE;

            SendMsg(ioInfo->buffer, bytesTrans); // broadcast

            ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
            memset(&(ioInfo->overlapped), 0, sizeof(OVERLAPPED));
            ioInfo->wsaBuf.len = BUF_SIZE;
            ioInfo->wsaBuf.buf = ioInfo->buffer;
            ioInfo->rwMode = READ;

            WSARecv(sock, &(ioInfo->wsaBuf), 1, NULL, &flags, &(ioInfo->overlapped), NULL);
        }
        else
        {
            free(ioInfo);
        }
    }
    return 0;
}

void SendMsg(char *msg, int len)
{ // 发送给全部人
    int i;
    WaitForSingleObject(hMutex, INFINITE);
    for (i = 0; i < clntCnt; i++)
        send(clntSocks[i].hClntSock, msg, len, 0);
    ReleaseMutex(hMutex);
}

void ErrorHandling(char *msg)
{
    fputs(msg, stderr);
    fputc('\n', stderr);
    exit(1);
}

编译:

gcc IOCPChatServ.c -lws2_32 -o IOCPChatServ

运行结果:

在这里插入图片描述

TCP/IP网络编程:从基础到高级I/O模型 TCP/IP(Transmission Control Protocol/Internet Protocol)是一个分层的通信协议系统。网络数据的传输需要经过层层封装与解析,每一层都负责不同的通信任务。最底层为链路层,负责主机之间的物理数据传输,而最高层为应用层,它支持应用程序之间进行交互。理解TCP/IP协议栈的工作原理,是深入学习网络编程的基础。套接字(socket)编程是网络编程的核心,它为应用程序提供了访问底层网络协议的能力。 阅读详情

相关推荐

C++源代码实战:BBTCP5.3的IOCP异步网络编程引擎

网络编程是一种使计算机能够通过网络连接进行数据交换的技术。在C++中,TCP是用于实现网络通信的一种协议,它为网络通信提供了可靠的、面向连接的服务。TCP/IP模型在C++网络编程中占据了核心地位,确保了数据能够准确无误地从源头传输到目的地。服务器将采用异步I/O操作来处理客户端连接和消息。这包括使用IOCP来管理并发的客户端请求,并通过异步读写来实现高效的数据传输。以下为服务器的简化设计步骤:初始化IOCP对象:创建IOCP对象并关联监听套接字。接受客户端连接:使用。

weixin_36151775的博客 521

《TCP/IP网络编程》第23章 IOCP

《TCP/IP网络编程》第23章通过重叠I/O理解IOCP非阻塞模式的套接字纯重叠方式实现回声服务器端重新实现客户端从重叠I/O模型到IOCP模型分阶段实现IOCP程序创建“完成端口"连接完成端口对象和套接字确认完成端口已完成的I/O和线程的I/O处理IOCP回声服务器端IOCP特点 通过重叠I/O理解IOCP IOCP(Input Output Completion Port,输入输出完成端口)。 非阻塞模式的套接字 SOCKET hLisnSock; int mode=1; hLisnSock=WSA

yxqq378287007的博客 458

构建高性能UDP服务器:完成端口IOCP+UDP源码实战

用户数据报协议(UDP)是一种简单的无连接协议,为网络应用提供了一种无需建立连接就能发送数据的方式。与传输控制协议(TCP)相比,UDP具有以下特点:无连接:UDP发送数据前不需要建立连接,减少了延迟。尽最大努力交付:UDP不会对数据进行排序或者确认,如果数据丢失或重复也不会进行重传。轻量级:由于省去了建立连接和重传机制的开销,UDP头部只有8字节,比TCP的20字节头部要小。不可靠。

weixin_35636570的博客 910

网络编程:IOCP与异步IO模型深度解析

IOCP(I/O Completion Port)是Windows操作系统提供的一种高效处理异步I/O请求的机制,它通过预分配的线程池和完成事件通知来提升多处理器系统上的I/O处理效率。与Linux中的Reactor模型不同,IOCP模型将I/O检测和操作都交由内核完成,用户线程只需等待完成通知。

平平无奇的小甜菜 1378

利用IOCP实现高性能Socket服务器端源码

本文还有配套的精品资源,点击获取 简介:IOCP是Windows中的高效I/O模型,适用于大量并发I/O操作,通过分离I/O操作与通知机制,实现非阻塞式处理请求,提高服务器性能。该示例源码展示了一个基于IOCP和Socket技术的游戏服务器端程序,支持TCP/IP和UDP协议,并且在VC++环境中开发。项目中关键组件包括服务器的启动和初始化、接受新连接、数据收发、错误处理与...

weixin_31961675的博客 975

SpringBoot与锐浪报表服务器深度整合实战指南

本文详细介绍了SpringBoot与锐浪报表服务器的深度整合实战指南,包括环境准备、Windows/Linux系统配置、核心功能实现代码解析及常见问题解决方案。通过具体案例和代码示例,帮助开发者高效完成报表系统的集成与部署,提升企业级应用的报表处理能力。

weixin_29238147的博客 370

TCP/IP网络编程_基于Windows的编程_第23章IOCP

23.1 通过重叠 I/O 理解 IOCP 本章的 IOCP (Input Output Completion Port, 输入输出完成端口) 服务器端模型是很多 Windows 程序员关注的焦点. 各位若急于求成而跳过了第21章

weifc-wei 的博客 418

Windows环境下DataEase一站式安装指南(含WSL2+Docker配置)

本文详细介绍了在Windows环境下通过WSL2和Docker快速部署DataEase的完整教程。从WSL2配置、Docker环境搭建到DataEase离线安装,逐步指导用户完成一站式部署,特别适合需要快速搭建数据分析平台的开发者。教程包含常见问题解决方案和性能优化技巧,帮助用户高效使用这款国产开源数据可视化工具。

weixin_42526166的博客 399

网络编程——IOCP

参考 《TCP/IP网络编程》 尹圣雨 IOCP IOCP(Input Output Completion Port,输入输出完成端口)是性能最好的Windows平台I/O模型。Linux有epoll,BSD有kqueue。 从重叠I/O理解IOCP 实现非阻塞模式的套接字 在Windows中通过ioctlsocket函数将套接字属性改为非阻塞式,其调用的含义是,将hLisnSock句柄引用的套接字I/O模式(FIONBIO)改为变量mode中指定的形式 SOCKET hLisnSock; int mo

beilizhang的博客 2459

用Python手把手教你实现一个多层感知机(MLP)——从理论到代码实战

本文详细介绍了如何使用Python和Theano库从零开始实现多层感知机(MLP),涵盖从核心原理到代码实战的全过程。通过构建隐藏层、输出层和完整MLP模型,结合权重初始化、激活函数选择和训练技巧,帮助开发者深入理解神经网络工作机制,并应用于实际机器学习任务。

web39explorer的博客 971

Ansys Lumerical 启动时出现 Error: Could not connect to Ansys license server specified at 1055@ 的一种解决办法

考虑到 2020 版的时候是直接在全局变量里指定具体地址,但是 2024 版本是写成 1055@localhost ,并且之后在站里搜相关 Ansys 的问题都指向 1055 端口被占用,虽然问题不一样,但是本着死马当活马医,就按照。我最近在跑超透镜结构,听说2024版本现在有GPU加速可以用,就把Lumerical从2020升到2024版本,结果发现一开头的破解办法完全不一样了。一开始安装的时候以为2020没有删干净,导致2024版的安装一直锁着目标地址,解决办法参考。的办法来操作,在关闭了。

qq_51404184的博客 5765

《TCP/IP网络编程》IOCP 完成端口技术

IOCP 完成端口技术 完成端口技术,IOCP(complete port) 就是系统帮你完成网络IO操作,在客户端极多的情况下,这种模型效率很高。 多线程模型下:每个客户端都分配一个线程的话,那么CPU会把大部分时间片都浪费在线程之间的调度上,而不是每个线程中对网络数据的处理上。 而I/O重叠模型让CPU的工作更多集中在网络数据的处理而非线程调度。 一个很有趣的比喻:IOCP技术相当于...

ChristmasError的博客 561

基于STM32F407ZGT6与INMP441的I2S音频采集系统:从配置到实时波形显示

本文详细介绍了基于STM32F407ZGT6与INMP441麦克风模块的I2S音频采集系统设计与实现。从硬件选型、CubeMX配置到音频数据处理和上位机波形显示,全面解析了系统架构、DMA传输优化及常见问题解决方案,帮助开发者快速构建高精度音频采集系统。

weixin_33743661的博客 403

《TCP/IP网络编程》学习笔记 | Chapter 24:制作 HTTP 服务器端

《TCP/IP网络编程》学习笔记 | Chapter 24:制作 HTTP 服务器端

ProgramNovice的博客 496

电子元件及其规格书的查找与理解

本内容收录:在电子开发或维修过程中,查找电子元件及其规格书心得体会,以及元件规格书的理解,系个人多年实战经验的系统梳理。内容着重介绍贴片元件代码反查型号的实用技巧,并以三款典型疑难元件为例,详述其完整查找过程与最终型号确认。

让你爱上电路设计 3996

MicroPython学习:在STM32上进行移植

本文将介绍如何在STM32上移植MicroPython,并提供相应的源代码。通过以上步骤,你已经成功地将MicroPython移植到STM32上,并可以使用MicroPython语言编写和运行代码。你可以进一步探索MicroPython的功能和API,以利用STM32的各种外设和功能。使用STM32CubeProgrammer或其他适当的烧录工具,将编译生成的MicroPython固件烧录到STM32微控制器中。打开该文件,并根据你的STM32微控制器类型进行必要的配置更改。模块来控制STM32的LED。

JeeVue的博客 1238

【读书笔记】TCP/IP 网络编程 第23章 IOCP模型

IOCP模型IOCP中已完成的I/O信息将注册到完成端口对象(Completion Port,简称CP对象)。但这个过程并非简单的注册,需要如下两个工作: 创建完成端口对象 建立完成端口对象和套接字之间的联系 此时的套接字必须被赋予重叠属性。(异步I/O)创建CP对象 CreateIoCompletoinPort() 前三个参数是无意义的,只有最后一个参数有意义:表示分配给CP对象的处理I/O的线程

xiaxzhou的博客 584

诊断数据库ODX标准协议ISO22901定义组成部分

综上所述,简略描述了ODX数据库中UML/XML/Text/Check rules具体功能以及详细内容。

Soly_kun的博客 907

【网络编程】完成端口 IOCP

执行一个文件的I/O 操作处理具有关联的I/O 完成端口,在I/O 操作完成时I/O 系统发送 完成通知包到完成端口。其次,我们需要知道,所谓的完成端口其实和 HANDLE 一样,也是一个内核对象, Windows 大师Jeff Richter曾说,“完成端口可能是最为复杂的内核对象了”,但是我们也不 用去管它复杂,因为具体的内部是如何实现的和我们无关,只要我们能够学会用它相关的API 把这个完成端口的框架搭建起来就可以了。然而,当一个事件发生的时候,此完成端口就将被操作系统加入一个队列中。

Antonio915的博客 910

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

什么是IOCP?

什么是IOCP?转载: 理解I/O Completion Port    欢迎阅读此篇IOCP教程。我将先给出IOCP的定义然后给出它的实现方法,最后剖析一个Echo程序来为您拨开IOCP的谜云,除去你心中对IOCP的烦恼。OK,但我不能保证你明白IOCP的一切,但我会尽我最大的努力。以下是我会在这篇文章中提到的相关技术:  I/O端口  同步/异步  堵塞/非堵塞  服务端/客户

水上漂的专栏 1610

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

TCP/IP网络编程 第二十三章:IOCP

简要的介绍了一下在Windows操作系统下的一个高性能服务器模型-----IOCP

Reol99999的博客 850

网络编程五种IO模型之IOCP模型

/* client.cpp */ #include #include #include #include #include "Globle.h" #pragma comment(lib, "ws2_32.lib") #define MAX_THREAD 5 HANDLE ThreadPool[MAX_THREAD] = {NULL}; volatile BOOL bE

phymat.nico的专栏 1011

IOCP简介

1.1 环境要求本文读者需要熟悉C++、TCP/IP、Socket编程、MFC,和多线程。源码使用Winsock 2.0和IOCP技术,要求:Windows NT/2000或以上:要求Windows NT3.5或以后版本Windows 95/98/ME:不支持Visual C++.NET,或完整更新过的Visual C++ 6.01.2 摘要当 你开发不同类型的软件,你迟早必须处理C/S的开发。对...

weixin_33979363的博客 4189

基于IOCP的HTTP服务器

本项目的重点是IOCP,至于HTTP服务,暂时只实现了GET方法,在浏览器输入IP:端口,则返回hello字符串。后面有空继续实现HTTP协议的其它方法。 首先对于一个服务器,首先要解决以下几个问题: 如何检测有新客户端连接? 如何接受客户端连接? 如何检测客户端是否有数据发来? 如何收取客户端发来的数据? 如何检测连接异常?发现连接异常之后,如何处理? 如何给客户端发送数据? 如...

回头太难 1565

谈谈网络编程(基于C++)

这篇文章讲了一点网络编程的一些新路,一点体悟。学习就是这种不断总结提高的过程。 设计到进程,线程,线程池,reactior和proactor并发编程模式,IOCP,linux下的epoll。。。。。 我从事的是企业级的软件开发,纵观当今的企业级软件,单机模型已经越来越少,更多的是C/S模型,目前 client 和 server 之间通信是通过 socket 技术来实现的。 上面提到了 socket 技术,自然要学习 TCP/IP 协议,对于 TCP/IP 的理论,学习 Richard 的《TCP/IP 详解

hjseo_seg的博客 500

网络编程与IOCP

Windows下的网络编程,IOCP(IO Completion Port)作为windows下效率最好的网络编程模型,可能是必须了解和掌握的知识。要理解IOCP,也必须了解有关网络编程的方方面面的知识。 有很长时间没有做网络编程方面的工作,因为需要,必须重新捡起来这方面的知识,同时整理成章。 作为随笔,相对比较杂乱,更多注重理解领会,文字多些,而代码少些。 一,相关知识:阻塞与非阻塞(bloc...

weixin_33895016的博客 147
上一篇: 《TCP/IP网络编程》学习笔记 | Chapter 22:重叠 I/O 模型
下一篇: 《TCP/IP网络编程》学习笔记 | Chapter 24:制作 HTTP 服务器端
UestcXiye
博客等级 码龄8年 9033粉丝 1306原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

UestcXiye

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

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

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

打赏作者

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

抵扣说明:

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

余额充值