《TCP/IP网络编程》学习笔记 | Chapter 21:异步通知 I/O 模型

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

《TCP/IP网络编程》学习笔记 | Chapter 21:异步通知 I/O 模型

《TCP/IP网络编程》学习笔记 | Chapter 21:异步通知 I/O 模型

同步与异步

同步

同步指的是任务按照顺序执行,一个任务必须等待前一个任务完成后才能继续。换句话说,在进行同步操作时,程序会阻塞在某个操作上,直到该操作完成后才会继续往下执行。

同步方式的数据 I/O:

在这里插入图片描述

可以通过下图解析上述两句话的含义:

在这里插入图片描述

异步

异步是指任务并行执行,程序发起一个操作后不等待其完成,而是继续执行其他任务。程序可以在等待操作完成的同时执行其他操作,最终通过回调、事件、信号等方式获取操作结果。

异步 I/O 是指 I/O 函数的返回时刻与数据接收的完成时刻不一致。

在这里插入图片描述

对比

在这里插入图片描述

同步 I/O 的缺点

进行 I/O 的过程中函数无法返回,所以不能执行其他任务。

异步 I/O 的优点

无论数据是否完成交换都返回函数,这就意味着可以执行其他任务。

异步方式能够比同步方式更有效使用 CPU。

理解异步通知 I/O 模型

通知 I/O 的含义:

在这里插入图片描述

顾名思义,通知 I/O 是指发生了I/O相关的特定情况。典型的通知 I/O 模型是 select 方式,但这种通知是以同步方式进行的,原因在于,需要 I/O 或可以进行 I/O 的时间点(简言之就是 I/O 相关事件发生的时间点)与 select 函数的返回时间点一致。

异步通知 I/O 模型意为通知 I/O 是以异步方式工作的。与“select 函数只在需要或可以进行 I/O 的情况下返回”不同,异步通知 I/O 模型中函数的返回与 I/O 状态无关。

本章的 WSAEventSelect 函数就是 select 函数的差异版本。

可能有人疑问:“既然函数的返回与I/O状态无关,那是否需要监视 I/O 状态变化?”

当然需要!异步通知 I/O 中,指定 I/O 监视对象的函数和实际验证状态变化的函数是相互分离的。因此,指定监视对象后可以离开执行其他任务,最后再回来验证状态变化。

实现异步通知 I/O 模型

异步通知 I/O 模型的实现方法有 2 种:一种是稍后介绍的 WSAEventSelect 函数,第二种是使用 WSAAsyncSelect 函数,第二种方法是 UI 相关内容,不进行介绍,需要了解可自行查阅资料。

WSAEventSelect 函数和通知

如前所述,告知 I/O 状态变化的操作就是“通知”。I/O的状态变化可以分为不同情况:

  • 套接字的状态变化:套接字的I/O状态变化。
  • 发生套接字相关事件:发生套接字I/O相关事件。

这 2 种情况都意味着发生了需要或可以进行 I/O 的事件,我将根据上下文适当混用这些概念。

WSAEventSelect 是 Windows Sockets API(Winsock)中的一个函数,用于将一个 Windows 事件对象与一个套接字(socket)关联,以便在套接字状态发生变化时获得通知。这个函数常用于异步网络编程,特别是在处理多个套接字时。

#include<winsock2.h>

int WSAEventSelect(SOCKET s,
				   HANDLE hEvent,
				   long lNetworkEvents
);

参数:

  • s:监视对象的套接字句柄。
  • hEventObject:传递事件对象句柄以验证事件发生与否。
  • INetworkEvents:希望监视的事件类型信息。

成功时返回 0,失败时返回 SOCKET_ERROR。

传入参数 s 的套接字内只要发生 INetworkEvents 中指定的事件之一,WSAEventSelect 函数就将 hEventObject 句柄所指内核对象改为 signaled 状态。因此,该函数又称“连接事件对象和套接字的函数”。该函数以异步通知方式工作。无论事件发生与否,WSAEventSelect 函数调用后都会直接返回。

下面介绍作为该函数第三个参数的事件类型信息,可以通过位或运算同时指定多个信息。

  • FD_READ:是否存在需要接收的数据?
  • FD_WRITE:能否以非阻塞方式传输数据?
  • FD_OOB:是否收到带外数据?
  • FD_ACCEPT:是否有新的连接请求?
  • FD_CLOSE:是否有断开连接的请求?

以上就是 WSAEventSelect 函数的调用方法。

仅从概念上看,WSAEventSelect函数 的功能偏弱。但使用该函数时,没必要针对多个套接字进行调用。从 select 函数返回时,为了验证事件的发生需要再次针对所有句柄调用函数,但通过调用 WSAEventSelect 函数传递的套接字信息已注册到操作系统,所以无需再次调用。这反而是 WSAEventSelect 函数比 select 函数的优势所在。

从函数说明中可以看出,我们还需要知道以下内容:

  1. WSAEventSelect 函数的第二个参数中用到的事件对象的创建方法。
  2. 调用 WSAEventSelect 函数后发生事件的验证方法。
  3. 验证事件发生后事件类型的查看方法。

manual-reset 模式事件的其他创建方法

之前创建事件对象是利用 CreateEvent 函数。 CreateEvent 函数在创建事件对象时,可以在 auto-reset 模式和 manual-reset 模式中任选其一。但是我们只需要 manual-reset 模式 non-signaled 状态的事件对象,所以利用下面的函数创建比较方便。

#include <winsock2.h>

WSAEVENT WSACreateEvent(void);

成功时返回事件对象句柄,失败时返回 WSA_INVALID_EVENT。

上述声明中返回类型 WSAEVENT 的定义如下:

#define WSAEVENT HANDLE

实际上就是我们熟悉的内核对象句柄。

另外,可使用如下函数销毁上述函数创建的事件对象:

#include <winsock2.h>

BOOL WSACloseEvent(WSAEVENT hEvent);

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

验证是否发生事件

为了验证是否发生事件,需要查看事件对象。完成该任务的函数如下,除了多 1 个参数外,其余部分与 WaitForMultipleObjects 函数完全相同。

#include <winsock2.h>

DWORD WSAWaitForMultipleEvents(
    DWORD cEvents,                // 要等待的事件对象数量
    const WSAEVENT* lphEvents,    // 指向事件对象句柄数组的指针
    BOOL fWaitAll,                // 指定是等待所有事件还是任何一个事件
    DWORD dwTimeout,              // 超时时间(毫秒)
    BOOL fAlertable               // 指定等待期间是否允许进入警报状态(APC)
);

参数:

  • cEvents:需要验证是否转为 signaled 状态的事件对象的个数。
  • IphEvents:存有事件对象句柄数组地址值。
  • fWaitAll:传递 TRUE 时,所有事件对象在 signaled 状态时返回;传递 FALSE 时,只要其中 1 个变为 signaled 状态就返回。
  • dwTimeout:以 1ms 为单位指定超时,传递 WSA_INFINITE 时,直到变为 signaled 状态时才会返回。
  • fAlertable:传递 TRUE 时进入 alertable_wait(可警告等待)状态(第 22 章)。

返回值减去常量 WSA_WAIT_EVENT_0 时,可以得到转变为 signaled 状态的事件对象句柄对应的索引,可以通过该索引在第二个参数指定的数组中查找句柄。如果有多个事件对象变为 signaled 状态,则会得到其中较小的值。发生超时将返回 WSA_WAIT_TIMEOUT。

可以通过以宏的方式声明的 WSA_MAXIMUM_WAIT_EVENTS 常量得知 WSAWaitForMultipleEvents 函数可以同时监视的最大事件对象数。该常量值为 64。

只通过 1 次函数调用无法得到转为 signaled 状态的所有事件对象句柄的信息。通过该函数可以得到转为 signaled 状态的事件对象中的第一个(按数组中的保存顺序)索引值。但可以利用 “事件对象为 manual-reset 模式” 的特点,通过如下方式获得所有 signaled 状态的事件对象。

int posInfo, startIdx, i;
...
// 等待 hEventArray 中的任意一个事件对象变为 signaled 状态
posInfo = WSAWaitForMultipleEvents(numOfSock, hEventarray, FALSE, WSA_INFINITE, FALSE);
// startIdx 是当前进入 signaled 状态的事件在 hEventArray 数组中的索引
startIdx = posInfo - WSA_WAIT_EVENT_0;
...
// 从第一个 signaled 的事件开始,遍历剩余的事件,检查它们是否已经被触发
for(i = startIdx; i < numOfSock; i++)
{
    // 仅检查 hEventArray[i] 这个单个事件对象是否被触发。由于超时时间为 0,它不会等待,只会立即返回结果
    int sigEventIdx = WSAWaitForMultipleEvents(1, &hEventArray[i], TRUE, 0, FALSE);
    ...
    // 如果这个事件已经 signaled,则 sigEventIdx 返回 WSA_WAIT_EVENT_0
    // 否则返回 WSA_WAIT_TIMEOUT 或 WSA_WAIT_FAILED
}

之所以能做到这一点,完全是因为事件对象为 manual-reset 模式,这也解释了为何在异步通知 I/O 模型中事件对象必须为 manual-reset 模式。

区分事件类型

既然已经通过WSAWaitForMultipleEvents函数得到了转为signaled状态的事件对象,最后就要确定相应对象进入signaled状态的原因。为完成该任务,我们引入如下函数。调用此函数时,不仅需要signaled状态的事件对象句柄,还需要与之连接的(由WSAEventSelect函数调用引发的)发生的套接字句柄。

#include <winsock2.h>

// 
int WSAEnumNetworkEvents(
    SOCKET s,                           // 套接字句柄
    WSAEVENT hEventObject,              // 可选的事件对象句柄
    LPWSANETWORKEVENTS lpNetworkEvents  // 指向 WSANETWORKEVENTS 结构的指针
);

参数:

  • s:发生事件的套接字句柄。该套接字应该与某个事件对象通过 WSAEventSelect 函数关联。
  • hEventObject:一个可选的事件对象句柄。如果这个参数非空,WSAEnumNetworkEvents 函数会自动将这个事件对象的状态重置为 non-signaled 状态。 如果传递的是 NULL,那么该函数仅仅返回网络事件信息,而不重置任何事件。
  • lpNetworkEvents:指向 WSANETWORKEVENTS 结构的指针,用于接收套接字的事件信息。此结构包含了发生的网络事件及其对应的错误码。

WSANETWORKEVENTS 结构体:

typedef struct _WSANETWORKEVENTS
{
    long lNetworkEvents;  // 事件的掩码(可以是多个事件的组合)
    int iErrorCode[FD_MAX_EVENTS];  // 每个事件对应的错误码
} WSANETWORKEVENTS, *LPWSANETWORKEVENTS;

上述结构体的 lNetworkEvents 成员将保存发生的事件信息,与 WSAEventSelect 函数的第三个参数相同,需要接收数据时,该成员为 FD_READ;有连接请求时,该成员为 FD_ACCEPT。因此,可通过如下方式查看发生的事件类型:

WSANETWORKEVENTS netEvents;
...
WSAEnumNetworkEvents(hSock, hEvent, &netEvents);
if(netEvents.lNetworkEvents & FD_ACCEPT)
{
    // FD_ACCEPT 事件的处理
}

if(netEvents.lNetworkEvents & FD_READ)
{
    // FD_READ 事件的处理
}

if(netEvents.lNetworkEvents & FD_CLOSE)
{
    // FD_CLOSE 事件的处理
}

另外,错误信息将保存到声明为成员的 iErrorCode 数组(发生错误的原因可能很多,因此用数组声明)。验证方法如下:

  • 如果发生 FD_READ 相关错误,则在 iErrorCode[FD_READ_BIT]中保存除 0 以外的其他值。
  • 如果发生 FD_WRITE 相关错误,则在 iErrorCode[FD_WRITE_BIT] 中保存除 0 以外的其他值。

可以通过以下的描述来理解上述内容:“如果发生 FD_XXX 相关错误,则在 iErrorCode[FD_XXX_BIT] 中保存除 0 以外的其他值”。

因此可以用如下方式检查错误:

WSANETWORKEVENTS netEvents;
...
WSAEnumNetworkEvents(hSock,hEvent,&netEvents);
...
if(netEvents.iErrorCode[FD_READ_BIT] != 0
{
	// 发生 FD_READ 事件相关错误
}

利用异步通知 I/O 模型实现回声服务器端

由于代码较长,所以将分成多个部分进行介绍。

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

#define BUF_SIZE 100

void CompressSockets(SOCKET hSockArr[], int idx, int total);
void CompressEvents(WSAEVENT hEventArr[], int idx, int total);
void ErrorHandling(char *msg);

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET hServSock, hClntSock;
    SOCKADDR_IN servAdr, clntAdr;

    SOCKET hSockArr[WSA_MAXIMUM_WAIT_EVENTS];
    WSAEVENT hEventArr[WSA_MAXIMUM_WAIT_EVENTS];
    WSAEVENT newEvent;
    WSANETWORKEVENTS netEvents;

    int numOfClntSock = 0;
    int strLen, i;
    int posInfo, startIdx;
    int clntAdrLen;
    char msg[BUF_SIZE];

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

以上是初始化和声明代码,没有什么要特别说明的。

    hServSock = socket(PF_INET, SOCK_STREAM, 0);
    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");

    newEvent = WSACreateEvent();
    if (WSAEventSelect(hServSock, newEvent, FD_ACCEPT) == SOCKET_ERROR)
        ErrorHandling("WSAEventSelect() error");

    hSockArr[numOfClntSock] = hServSock;
    hEventArr[numOfClntSock] = newEvent;
    numOfClntSock++;

上述代码创建了用于接收客户端连接请求的服务器端套接字。为了完成监听任务,针对 FD_ACCEPT 事件调用了 WSAEventSelect 函数。此处需要注意如下 2 条语句。

    hSockArr[numOfClntSock] = hServSock;
    hEventArr[numOfClntSock] = newEvent;

这段代码把通过 WSAEventSelect 函数连接的套接字和事件对象的句柄分别存入 hSockArr 和 hEventArr 数组。也就是说,应该可以通过 hSockArr[idx] 找到连接到套接字的事件对象,反之,也可以通过 hEventArr[idx] 找到连接到事件对象的套接字。因此,该示例将套接字和事件对象句柄保存到数组时统一了保存位置。也就有了下列公式:

  • 与 hSockArr[n] 中的套接字相连的事件对象应保存到 hEventArr[n]。
  • 与 hEventArr[n] 中的事件对象相连的套接字应保存到 hSockArr[n]。

接下来是 while 循环部分,之前学习的大部分内容都在此。

    while (1)
    {
        posInfo = WSAWaitForMultipleEvents(
            numOfClntSock, hEventArr, FALSE, WSA_INFINITE, FALSE);
        startIdx = posInfo - WSA_WAIT_EVENT_0;

        for (i = startIdx; i < numOfClntSock; i++)
        {
            int sigEventIdx =
                WSAWaitForMultipleEvents(1, &hEventArr[i], TRUE, 0, FALSE);
            if ((sigEventIdx == WSA_WAIT_FAILED || sigEventIdx == WSA_WAIT_TIMEOUT))
            {
                continue;
            }
            else
            {
                sigEventIdx = i;
                WSAEnumNetworkEvents(
                    hSockArr[sigEventIdx], hEventArr[sigEventIdx], &netEvents);
                if (netEvents.lNetworkEvents & FD_ACCEPT) // 请求连接时
                {
                    if (netEvents.iErrorCode[FD_ACCEPT_BIT] != 0)
                    {
                        puts("Accept Error");
                        break;
                    }
                    clntAdrLen = sizeof(clntAdr);
                    hClntSock = accept(
                        hSockArr[sigEventIdx], (SOCKADDR *)&clntAdr, &clntAdrLen);
                    newEvent = WSACreateEvent();
                    WSAEventSelect(hClntSock, newEvent, FD_READ | FD_CLOSE);

                    hEventArr[numOfClntSock] = newEvent;
                    hSockArr[numOfClntSock] = hClntSock;
                    numOfClntSock++;
                    puts("connected new client...");
                }

                if (netEvents.lNetworkEvents & FD_READ) // 接收数据时
                {
                    if (netEvents.iErrorCode[FD_READ_BIT] != 0)
                    {
                        puts("Read Error");
                        break;
                    }
                    strLen = recv(hSockArr[sigEventIdx], msg, sizeof(msg), 0);
                    send(hSockArr[sigEventIdx], msg, strLen, 0);
                }

                if (netEvents.lNetworkEvents & FD_CLOSE) // 断开连接时
                {
                    if (netEvents.iErrorCode[FD_CLOSE_BIT] != 0)
                    {
                        puts("Close Error");
                        break;
                    }
                    WSACloseEvent(hEventArr[sigEventIdx]);
                    closesocket(hSockArr[sigEventIdx]);

                    numOfClntSock--;
                    CompressSockets(hSockArr, sigEventIdx, numOfClntSock);
                    CompressEvents(hEventArr, sigEventIdx, numOfClntSock);
                }
            }
        }
    }

    WSACleanup();
    return 0;
}

最后给出上述代码调用的两个函数 CompressSockets 和 CompressEvents 的函数声明。

void CompressSockets(SOCKET hSockArr[], int idx, int total)
{
    int i;
    for (i = idx; i < total; i++)
        hSockArr[i] = hSockArr[i + 1];
}

void CompressEvents(WSAEVENT hEventArr[], int idx, int total)
{
    int i;
    for (i = idx; i < total; i++)
        hEventArr[i] = hEventArr[i + 1];
}

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

完整的服务器端代码:

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

#define BUF_SIZE 100

void CompressSockets(SOCKET hSockArr[], int idx, int total);
void CompressEvents(WSAEVENT hEventArr[], int idx, int total);
void ErrorHandling(char *msg);

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET hServSock, hClntSock;
    SOCKADDR_IN servAdr, clntAdr;

    SOCKET hSockArr[WSA_MAXIMUM_WAIT_EVENTS];
    WSAEVENT hEventArr[WSA_MAXIMUM_WAIT_EVENTS];
    WSAEVENT newEvent;
    WSANETWORKEVENTS netEvents;

    int numOfClntSock = 0;
    int strLen, i;
    int posInfo, startIdx;
    int clntAdrLen;
    char msg[BUF_SIZE];

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

    hServSock = socket(PF_INET, SOCK_STREAM, 0);
    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");

    newEvent = WSACreateEvent();
    if (WSAEventSelect(hServSock, newEvent, FD_ACCEPT) == SOCKET_ERROR)
        ErrorHandling("WSAEventSelect() error");

    hSockArr[numOfClntSock] = hServSock;
    hEventArr[numOfClntSock] = newEvent;
    numOfClntSock++;

    while (1)
    {
        posInfo = WSAWaitForMultipleEvents(
            numOfClntSock, hEventArr, FALSE, WSA_INFINITE, FALSE);
        startIdx = posInfo - WSA_WAIT_EVENT_0;

        for (i = startIdx; i < numOfClntSock; i++)
        {
            int sigEventIdx =
                WSAWaitForMultipleEvents(1, &hEventArr[i], TRUE, 0, FALSE);
            if ((sigEventIdx == WSA_WAIT_FAILED || sigEventIdx == WSA_WAIT_TIMEOUT))
            {
                continue;
            }
            else
            {
                sigEventIdx = i;
                WSAEnumNetworkEvents(
                    hSockArr[sigEventIdx], hEventArr[sigEventIdx], &netEvents);
                if (netEvents.lNetworkEvents & FD_ACCEPT) // 请求连接时
                {
                    if (netEvents.iErrorCode[FD_ACCEPT_BIT] != 0)
                    {
                        puts("Accept Error");
                        break;
                    }
                    clntAdrLen = sizeof(clntAdr);
                    hClntSock = accept(
                        hSockArr[sigEventIdx], (SOCKADDR *)&clntAdr, &clntAdrLen);
                    newEvent = WSACreateEvent();
                    WSAEventSelect(hClntSock, newEvent, FD_READ | FD_CLOSE);

                    hEventArr[numOfClntSock] = newEvent;
                    hSockArr[numOfClntSock] = hClntSock;
                    numOfClntSock++;
                    puts("connected new client...");
                }

                if (netEvents.lNetworkEvents & FD_READ) // 接收数据时
                {
                    if (netEvents.iErrorCode[FD_READ_BIT] != 0)
                    {
                        puts("Read Error");
                        break;
                    }
                    strLen = recv(hSockArr[sigEventIdx], msg, sizeof(msg), 0);
                    send(hSockArr[sigEventIdx], msg, strLen, 0);
                }

                if (netEvents.lNetworkEvents & FD_CLOSE) // 断开连接时
                {
                    if (netEvents.iErrorCode[FD_CLOSE_BIT] != 0)
                    {
                        puts("Close Error");
                        break;
                    }
                    WSACloseEvent(hEventArr[sigEventIdx]);
                    closesocket(hSockArr[sigEventIdx]);

                    numOfClntSock--;
                    CompressSockets(hSockArr, sigEventIdx, numOfClntSock);
                    CompressEvents(hEventArr, sigEventIdx, numOfClntSock);
                }
            }
        }
    }

    WSACleanup();
    return 0;
}

void CompressSockets(SOCKET hSockArr[], int idx, int total)
{
    int i;
    for (i = idx; i < total; i++)
        hSockArr[i] = hSockArr[i + 1];
}

void CompressEvents(WSAEVENT hEventArr[], int idx, int total)
{
    int i;
    for (i = idx; i < total; i++)
        hEventArr[i] = hEventArr[i + 1];
}

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

回声客户端:

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

#define BUF_SIZE 1024

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

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET hSocket;
    SOCKADDR_IN serverAddr;

    char message[BUF_SIZE];
    int strLen;

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

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

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

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

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

    while (1)
    {
        fputs("Input message(Q to quit): ", stdout);
        fgets(message, BUF_SIZE, stdin);

        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;

        send(hSocket, message, strlen(message), 0);
        strLen = recv(hSocket, message, BUF_SIZE - 1, 0);
        message[strLen] = '\0';
        printf("Message from server: %s\n", message);
    }

    closesocket(hSocket);
    WSACleanup();

    return 0;
}

编译:

gcc AsynNoticeEchoServer_win.c -lws2_32 -o asynNoticeEchoServ
gcc echo_client_win.c -lwsock32 -o echoClnt

运行结果:

在这里插入图片描述

在这里插入图片描述

习题

(1)结合 send & recv 函数解释同步和异步方式的 I/O。并请说明同步 I/O 的缺点,以及怎样通过异步 I/O 进行解决。

同步 I/O:

在这里插入图片描述

在这里插入图片描述

异步 I/O:

在这里插入图片描述

同步 I/O 的缺点:

  1. 资源浪费:线程在阻塞期间无法执行任何操作,导致 CPU 闲置。高并发场景需要大量线程,增加内存和上下文切换开销。
  2. 可扩展性差:每个连接需要一个线程/进程,难以支持大规模并发
  3. 若多个线程因 I/O 相互等待,可能导致死锁。

异步 I/O 的解决方案:

  • 单线程通过事件驱动处理多个 I/O 操作,减少线程/进程数量。
  • 基于事件循环(如 epoll)或协程实现百万级并发连接。
  • 通过非阻塞调用和回调机制,仅在 I/O 就绪时处理数据,最大化 CPU 利用率。

(2)异步 I/O 并不是所有情况下的最佳选择。它具有哪些缺点?何种情况下同步 I/O 更优?可以参考异步 I/O 相关源代码,亦可结合线程进行说明。

异步 I/O 的缺点:

  1. 异步 I/O 通常依赖回调函数或协程,容易导致代码嵌套过深。
  2. 异步高并发模型依赖操作系统支持大量文件描述符,若系统 ulimit 配置不当,可能直接导致程序崩溃。
  3. 单线程异步模型在处理 CPU 密集型任务时,无法利用多核 CPU。需配合多进程或线程池,反而增加复杂度。

同步 I/O 更优的场景:

  1. 简单业务逻辑与低并发需求
  2. 多线程并行计算
  3. 某些库(如数据库驱动)仅提供同步 API。强行异步化需额外封装,可能得不偿失
  4. 同步代码结构线性,适合团队协作或遗留系统维护

(3)判断下列关于 select 模型描述的正误。

  • select 模型通过函数的返回值通知 I/O 相关事件,故可视为通知 I/O 模型。(√)
  • select 模型中 I/O 相关事件的发生时间点和函数返回的时间点一致,故不属于异步模型。(√)
  • WSAEventSelect 函数可视为 select 方式的异步模型,因为该函数的 I/O 相关事件的通知方式为异步方式。(×)

(4)请从源代码的角度说明 select 函数和 WSAEventSelect 函数在使用上的差异。

select 是一种较为基础的多路复用 I/O 监控机制,适用于较小规模的网络编程,并且具有跨平台兼容性,但随着监控套接字数量的增加,性能会显著下降。

WSAEventSelect 采用事件驱动的异步 I/O 机制,特别适合大量并发连接的网络编程,在 Windows 平台上使用更为高效,但只能在 Windows 上使用。

在这里插入图片描述

(5)第 17 章的 epoll 可以在条件触发和边缘触发这 2 种方式下工作。哪种方式更适合异步 I/O 模型?为什么?请概括说明。

边缘触发(Edge-Triggered, ET)模式更适合异步 I/O 模型,原因如下:

  1. 避免阻塞和等待:ET 模式通过单次通知强制应用程序一次性处理数据,减少后续等待。
  2. 最小化系统调用:ET 仅在状态变化时通知一次,降低内核与应用层交互的频率。
  3. 高吞吐和低延迟:ET 结合非阻塞 I/O 可最大限度利用缓冲区,减少数据滞留。

此外,LT 模式在以下场景中表现不佳:

  • 高频小数据包:频繁触发事件,导致 CPU 空转。
  • 高并发连接:需遍历所有就绪的 socket,时间复杂度为 O(n)。
  • 资源浪费:未及时处理的数据会反复触发事件,增加无效的系统调用。

总之,边缘触发通过单次通知、强制非阻塞处理和最小化系统调用,更契合异步 I/O 模型的高效性和事件驱动特性。而条件触发更适合简单的同步编程场景,但在高并发异步环境中容易引发性能瓶颈。

(6)Linux 中的 epoll 同样属于异步 I/O 模型。请说明原因。

epoll 通过事件通知机制来告知用户线程哪些文件描述符已经就绪,可以进行 I/O 操作。用户线程在等待事件时,不会一直阻塞在 I/O 操作上,而是可以通过 epoll_wait 函数等待多个文件描述符的事件,一旦有事件发生,epoll 会通知用户线程,用户线程再根据通知去处理相应的 I/O 操作。

(7)如何获取 WSAWaitForMultipleEvents 函数可以监视的最大句柄数?请编写代码读取该值。

可以通过以宏的方式声明的 WSA_MAXIMUM_WAIT_EVENTS 常量得知 WSAWaitForMultipleEvents 函数可以同时监视的最大事件对象数。该常量值为 64。

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

int main()
{
    printf("%d\n", WSA_MAXIMUM_WAIT_EVENTS);

    system("pause");
    return 0;
}

运行结果:

在这里插入图片描述

(8)为何异步通知 I/O 模型中的事件对象必须是 manual-reset 模式?

  1. 确保所有线程都能接收到事件
    • 在异步通知 I/O 模型中,一个事件对象通常用于通知多个线程或处理多个 I/O 操作。当事件对象处于信号状态时,所有等待这个事件的线程都会被唤醒。如果事件对象是 auto-reset 模式,则一旦一个线程被唤醒,事件对象会被自动重置为非信号状态,这会导致其他线程无法再次接收到相同的事件通知。
    • manual-reset 事件对象允许事件状态保持为信号状态,直到显式重置,这确保了所有等待该事件的线程都能被通知到,避免遗漏事件通知。
  2. 适合处理高并发
    在高并发的异步 I/O 模型中,可能有大量的线程或 I/O 操作需要处理相同的事件。使用 manual-reset 事件对象可以减少对事件对象状态的频繁修改,提高系统效率,避免因事件状态自动重置导致的复杂同步问题。
  3. 减少事件通知的复杂性
    使用 manual-reset 事件对象简化了事件通知机制,因为不需要担心事件对象状态会被自动重置,从而避免了可能的竞争和线程同步问题。程序可以显式地控制何时重置事件对象,并且确保所有需要的线程都能正确地响应事件通知。

(9)请在本章的通知 I/O 模型的基础上编写聊天服务器端。要求该服务器端能够结合第 20 章的聊天客户端 chat_clnt_win.c 运行。

聊天服务器端:

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

#define BUF_SIZE 100

void CompressSockets(SOCKET hSockArr[], int idx, int total);
void CompressEvents(WSAEVENT hEventArr[], int idx, int total);
void SendMsg(char *msg, int len);
void ErrorHandling(char *msg);

int numOfClntSock = 0;
SOCKET hSockArr[WSA_MAXIMUM_WAIT_EVENTS];

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET hServSock, hClntSock;
    SOCKADDR_IN servAdr, clntAdr;

    WSAEVENT hEventArr[WSA_MAXIMUM_WAIT_EVENTS];
    WSAEVENT newEvent;
    WSANETWORKEVENTS netEvents;

    int strLen, i;
    int posInfo, startIdx;
    int clntAdrLen;
    char msg[BUF_SIZE];

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

    hServSock = socket(PF_INET, SOCK_STREAM, 0);
    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");

    newEvent = WSACreateEvent();
    if (WSAEventSelect(hServSock, newEvent, FD_ACCEPT) == SOCKET_ERROR)
        ErrorHandling("WSAEventSelect() error");

    hSockArr[numOfClntSock] = hServSock;
    hEventArr[numOfClntSock] = newEvent;
    numOfClntSock++;

    while (1)
    {
        posInfo = WSAWaitForMultipleEvents(numOfClntSock, hEventArr, FALSE, WSA_INFINITE, FALSE);
        startIdx = posInfo - WSA_WAIT_EVENT_0;

        for (i = startIdx; i < numOfClntSock; i++)
        {
            int sigEventIdx = WSAWaitForMultipleEvents(1, &hEventArr[i], TRUE, 0, FALSE);
            if ((sigEventIdx == WSA_WAIT_FAILED || sigEventIdx == WSA_WAIT_TIMEOUT))
            {
                continue;
            }
            else
            {
                sigEventIdx = i;
                WSAEnumNetworkEvents(hSockArr[sigEventIdx], hEventArr[sigEventIdx], &netEvents);
                if (netEvents.lNetworkEvents & FD_ACCEPT) // 请求连接时
                {
                    if (netEvents.iErrorCode[FD_ACCEPT_BIT] != 0)
                    {
                        puts("Accept Error");
                        break;
                    }
                    clntAdrLen = sizeof(clntAdr);
                    hClntSock = accept(hSockArr[sigEventIdx], (SOCKADDR *)&clntAdr, &clntAdrLen);
                    newEvent = WSACreateEvent();
                    WSAEventSelect(hClntSock, newEvent, FD_READ | FD_CLOSE);

                    hEventArr[numOfClntSock] = newEvent;
                    hSockArr[numOfClntSock] = hClntSock;
                    numOfClntSock++;
                    puts("connected new client...");
                }

                if (netEvents.lNetworkEvents & FD_READ) // 接收数据时
                {
                    if (netEvents.iErrorCode[FD_READ_BIT] != 0)
                    {
                        puts("Read Error");
                        break;
                    }
                    strLen = recv(hSockArr[sigEventIdx], msg, sizeof(msg), 0);
                    SendMsg(msg, strLen); // broadcast
                }

                if (netEvents.lNetworkEvents & FD_CLOSE) // 断开连接时
                {
                    if (netEvents.iErrorCode[FD_CLOSE_BIT] != 0)
                    {
                        puts("Close Error");
                        break;
                    }
                    WSACloseEvent(hEventArr[sigEventIdx]);
                    closesocket(hSockArr[sigEventIdx]);

                    numOfClntSock--;
                    CompressSockets(hSockArr, sigEventIdx, numOfClntSock);
                    CompressEvents(hEventArr, sigEventIdx, numOfClntSock);
                }
            }
        }
    }

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

void CompressSockets(SOCKET hSockArr[], int idx, int total)
{
    int i;
    for (i = idx; i < total; i++)
        hSockArr[i] = hSockArr[i + 1];
}

void CompressEvents(WSAEVENT hEventArr[], int idx, int total)
{
    int i;
    for (i = idx; i < total; i++)
        hEventArr[i] = hEventArr[i + 1];
}

void SendMsg(char *msg, int len)
{ // 发送给全部人
    int i;
    for (i = 0; i < numOfClntSock; i++)
        send(hSockArr[i], msg, len, 0);
}

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

客户端:

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

#define BUF_SIZE 100
#define NAME_SIZE 20

unsigned WINAPI SendMsg(void *arg);
unsigned WINAPI RecvMsg(void *arg);
void ErrorHandling(char *msg);

char name[NAME_SIZE] = "[DEFAULT]";
char msg[BUF_SIZE];

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET hSock;
    SOCKADDR_IN servAdr;
    HANDLE hSndThread, hRcvThread;
    if (argc != 4)
    {
        printf("Usage: %s <IP> <port> <name>\n", argv[0]);
        exit(1);
    }
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHandling("WSAStartup() error!");

    sprintf(name, "[%s]", argv[3]);
    hSock = socket(PF_INET, SOCK_STREAM, 0);

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

    if (connect(hSock, (SOCKADDR *)&servAdr, sizeof(servAdr)) == SOCKET_ERROR)
        ErrorHandling("connect() error");

    hSndThread = (HANDLE)_beginthreadex(NULL, 0, SendMsg, (void *)&hSock, 0, NULL);
    hRcvThread = (HANDLE)_beginthreadex(NULL, 0, RecvMsg, (void *)&hSock, 0, NULL);

    WaitForSingleObject(hSndThread, INFINITE);
    WaitForSingleObject(hRcvThread, INFINITE);

    closesocket(hSock);
    WSACleanup();

    return 0;
}

unsigned WINAPI SendMsg(void *arg)
{
    SOCKET hSock = *((SOCKET *)arg);
    char nameMsg[NAME_SIZE + BUF_SIZE];
    while (1)
    {
        fgets(msg, BUF_SIZE, stdin);
        if (!strcmp(msg, "q\n") || !strcmp(msg, "Q\n"))
        {
            closesocket(hSock);
            exit(0);
        }
        sprintf(nameMsg, "%s %s", name, msg);
        send(hSock, nameMsg, strlen(nameMsg), 0);
    }
    return 0;
}

unsigned WINAPI RecvMsg(void *arg)
{
    int hSock = *((SOCKET *)arg);
    char nameMsg[NAME_SIZE + BUF_SIZE];
    int strLen;
    while (1)
    {
        strLen = recv(hSock, nameMsg, NAME_SIZE + BUF_SIZE - 1, 0);
        if (strLen == -1)
            return -1;
        nameMsg[strLen] = '\0';
        fputs(nameMsg, stdout);
    }
    return 0;
}

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

编译:

gcc AsynNoticeChatServer_win.c -lws2_32 -o asynNoticeChatServer
gcc chat_client_win.c -lwsock32 -o cclnt

运行结果:

在这里插入图片描述

Windows重叠IO模型网络编程实战:事件通知DEMO 在现代的网络编程实践中,I/O 模型的选择是影响程序性能和效率的关键因素之一。重叠I/O模型是一种高级的I/O模型,它允许应用程序执行其他操作,而不会被I/O操作阻塞。本章节将简要介绍重叠I/O模型的基本概念,并探讨其在应用程序中的应用。重叠I/O模型允许程序启动一个I/O操作,然后继续执行其他任务,而I/O操作在后台完成。这种模型在处理高并发的网络服务时显得尤为重要,它可以显著提高服务器的吞吐量。 阅读详情

相关推荐

Windows重叠I/O网络编程实战:完成例程DEMO

在TCP/IP网络模型中,物理层负责定义电气特性、物理设备、接口标准,以及传输介质。它确保了数据能在不同的物理媒介上以比特的形式成功传输。而数据链路层则在物理层之上,负责建立和维护节点间的链接,以及帧的传输、流量控制和错误检测等功能。这一层确保数据包能够可靠地在网络中传递,虽然这层依然不会关心数据包的内容,但为上层协议提供了可靠的链路。在深入探讨重叠I/O模型之前,理解传统I/O模型的局限性是至关重要的。

weixin_35756624的博客 1102

计算机网络 | I/O模型、网络模型(OSI七层及TCP/IP四层)

五种IO模型、OSI七层网络模型、TCP/IP四层网络模型详解。

仅以此博客记录日常学习工作中所思所得,水平有限,难登大雅,万望海涵。 4119

网络编程实践:服务器与客户端消息转发及多线程/异步I/O模型

服务器和客户端之间的数据交换基于TCP/IP协议,该协议为互联网上计算机之间的通信提供了基本的框架。每个通信会话涉及一个发送者和一个接收者,发送者将数据分割成数据包,通过网络发送至接收者,接收者负责将数据包重新组合成原始数据。Socket通信模型是网络编程中的基础,它提供了一种标准的进程间通信接口(API)。在该模型下,数据通过网络在不同主机上的进程间传输,每个进程可以看作是网络中的一个端点。Socket接口抽象了底层网络通信细节,允许开发者通过简单的API进行网络通信操作。

weixin_42153793的博客 487

《TCP/IP网络编程》学习笔记 | Chapter 22:重叠 I/O 模型

《TCP/IP网络编程》学习笔记 | Chapter 22:重叠 I/O 模型

ProgramNovice的博客 1527

高效网络编程:非阻塞套接字与异步I/O

本文深入探讨了非阻塞套接字的使用和异步I/O的概念。通过详细解析UNIX系统中的非阻塞套接字调用,展示了如何通过程序控制来避免阻塞,实现高效网络通信。同时,介绍了异步I/O的原理,包括信号驱动I/O的实现方式及其在UNIX和Windows平台上的差异。

weixin_42300144的博客 432

Quartus Prime v18.1 standard-QuartusPrimeV18.1标准版安装过程

Quartus Prime v18.1 standard安装破解过程 下载方式1:官网下载: https://fpgasoftware.intel.com/18.1/?edition=standard&platform=windows 下载方式2:可以从我的网盘下载安装包(如果链接未时效的话): 链接:https://pan.baidu.com/s/1bq4_FcNPSflU1zGJv__rvA 提取码:o0in ----------------------------------.

Alonger1988的博客 2万+

《TCP/IP网络编程》第21章 异步通知I/O模型

《TCP/IP网络编程》第21章理解异步通知I/O模型同步和异步同步I/O缺点及异步解决方案异步通知I/O模型实现异步通知I/O模型WSAEventSelect函数manual-reset模式事件对象的创建验证是否发生了事件区分事件类型异步通知I/O模型回声服务器 理解异步通知I/O模型 同步和异步 同步的关键是函数的调用及返回时刻,以及数据传输的开始和完成时刻。 调用send函数的瞬间开始传输数据,send函数执行完(返回)的时刻完成数据传输(数据完全传输到输出缓冲,操作系统完成网络传输)。 调用rec

yxqq378287007的博客 862

【软路由】旁路由使用配置教程

【软路由】旁路由使用配置教程简介旁路由好处旁路由配置步骤1、修改管理地址网段 简介 我们都知道,软路由一般有两种使用方式,一种是作为承担DHCP分配的主路由,而另一种就是作为不承担DHCP分配功能的旁路由使用。今天就来介绍如何将软路由配置成为旁路由。 旁路由好处 旁路由最大的好处就是它不承担DHCP分配任务,这意味着它的对网络的影响极小。即使突然故障也不会导致整个网络瘫痪。更别提软路由的配置复杂,用户可能还经常修改上面的网络配置,一旦出错就是整个网络瘫痪,如果家中还有其他人使用网络,影响实在是不好。 建议有

博客 4万+

网络编程——异步通知I/O模型

参考 《TCP/IP网络编程》 尹圣雨 异步通知I/O模型 异步I/O 同步I/O的缺点:进行I/O的过程中函数无法返回,所以不能执行其他任务 异步I/O是指I/O函数的返回时刻与数据收发的完成时刻不一致,是为了克服同步I/O的缺点而设计的模型。无论数据是否完成交互都返回函数,这就意味着可以执行其他任务,能够更有效地使用CPU 理解异步通知I/O模型 异步通知I/O模型,意为“通知I/O”以异步方式工作 通知I/O指发生了I/O相关的特定情况,即通知输入缓冲收到数据并需要读取,以及输出缓冲为空可以发送数

beilizhang的博客 857

matlab中的神经网络怎么用,matlab怎么搭建神经网络

图中 yi表示神经元i的输出,函数f称为激活函数 ( Activation Function )或转移函数 ( Transfer Function ) ,net称为净激活(net activation)。图中x1~xn是从其他神经元传来的输入信号,wij表示表示从神经元j到神经元i的连接权值,θ表示一个阈值 ( threshold ),或称为偏置( bias )。对于P,x1是行向量,x2是行向量。双极S形函数与S形函数主要区别在于函数的值域,双极S形函数值域是(-1,1),而S形函数值域是(0,1)。

wenangou的博客 6365

R语言:基于Spatstat包的单变量和双变量平面Ripley‘s K函数分析

因为网上查找得到的R语言K函数分析的资料很少,Spatstat包的介绍也很少,所以抛砖引玉。本文简单介绍了使用R语言spatstat包的Kest,Kcross(Lcross)和Kinhom方法进行了单变量和双变量平面Ripley's K函数分析的方法及代码,希望有所帮助。

hsdcmax的博客 1万+

TCP/IP网络编程_基于Windows的编程_第21章异步通知I/O模型

21.1 理解异步通知I/O模型 各位应该还记得介绍过的 select 函数, 它是实现并发服务器端的方法之一. 本章内容可以理解为 select 模型的改进方式. 理解同步和异步 首先解析 “异步(Asynchronous)的含义”. 异步主要指 “不一致”, 它在数据I/O中非常有用. 之前的 Windows 示例中主要通过send & recv 函数进行同步 I/O. 调用 send 函数时, 完成数据传输后才能从函数返回(确切地说, 只有把数据完全传输到) ...

weifc-wei 的博客 385

phpMyAdmin | mysqli::real_connect(): (HY000/2002): No such file or directory

第一次安装宝塔mysql服务是默认关闭的,需要手动打开,打开服务再次进入phpMyAdmin发现可以进入了。

吻等离子的博客 2880

I/O模型:从阻塞到异步的演进

I/O模型决定了程序与外部设备交互的效率,主要分为五种:阻塞I/O会完全阻塞进程;非阻塞I/O通过轮询减少等待;I/O多路复用通过单线程监控多个I/O;信号驱动I/O通过信号通知就绪;异步I/O则由内核完全处理。其中,I/O多路复用(如epoll)和异步I/O(如io_uring)最适合高并发场景。实际开发中应根据应用规模选择合适模型,中小规模可用I/O多路复用,大规模推荐异步I/O或成熟框架(如Netty),在性能和开发效率间取得平衡。

Qinti_mm的博客 1012

(二)使用VS2022克隆下载C++自制植物大战僵尸游戏教程

本文将介绍如何使用VS2022克隆下载《植物大战僵尸C++自制版本》。Gitee项目地址:Gitee仓库地址Github项目地址:Github仓库地址游戏官网地址(下载可直接运行)游戏官网。

尔灵尔亿的博客 4956

AMBA-CHI协议详解(三)

Write Transactions、Atomic transactions、 Stash transactions、 Dataless transactions的等各个事务的事务流。

Crazzy_M的博客 3182

TCP/IP网络编程 第二十一章:异步通知I/O模型

简单的介绍一下在Windows平台下异步IO通知模型的实现

Reol99999的博客 563

FM1288回声消除芯片调试方案 - 综述

专栏文章概览

优快云mianfeixiazai001的博客 1717

网络编程——重叠I/O模型

参考 《TCP/IP网络编程》 尹圣雨 重叠I/O模型 理解重叠I/O模型 同一线程内部向多个目标传输(或从多个目标接收)数据引起的I/O重叠现象称为“重叠I/O”。为了完成这项任务,调用的I/O函数应立即返回,因此前提条件是异步I/O。而且,为了完成异步I/O,调用的I/O函数应以非阻塞模式工作 Windows中重叠I/O的重点并非I/O本身,而是如何确认I/O完成时的状态 创建重叠I/O套接字 #include <winsock2.h> SOCKET WSASocket(int af,

beilizhang的博客 3485

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

探索异步I/O:从同步到非阻塞的性能优化之路

本文主要探讨了异步I/O操作的优势和应用场景,并通过对比同步I/O,阐述了异步I/O在高并发服务器中的性能优化作用。同时,文章还给出了一个使用Linux异步I/O函数实现的简单服务器示例,以展示异步I/O的实际应用。通过了解异步I/O的原理和实现,读者可以更好地应对大规模并发请求的处理挑战,提高服务器的性能和吞吐量。

silenceallat的博客 1073

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

《TCP/IP网络编程》第22章 重叠I/O模型

《TCP/IP网络编程》第22章理解重叠I/O模型重叠I/O重叠I/O的重点不在于I/O创建重叠I/O套接字 理解重叠I/O模型 异步方式处理I/O的方法。 重叠I/O 同一线程内部向多个目标传输(或从多个目标接收)数据引起的I/O重叠现象。 需要调用的I/O函数立即返回,非阻塞异步。 重叠I/O的重点不在于I/O Windows中重叠I/O的重点并非I/O本身,而是如何确认I/O完成时的状态。非阻塞模式的输入输出需要另外确认执行结果。 Windows平台下重叠I/O模型由非阻塞异步I/O函数和确认I/O完

yxqq378287007的博客 878

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

【UNIX网络编程】五种I/O模型,阻塞非阻塞同步异步问题详解

IO复用  在写简单的TCP/IP服务器-客户端程序时,客户端要同时处理两个输入:   标准输入 TCP套接字  在结束的时候,因为客户端正阻塞于标准输入上的read函数,服务器TCP虽然正确的给客户TCP发送了一个FIN,但是既然客户进程正在阻塞于从标准输入读入的过程,他将看不到这个EOF,直到从套接字读时为止。   这样的进程需要一种预先告之内核的能力,使得内核一旦发现进程指定的一个或多个I/

lixungogogo的博客 2540

TCP/IP网络编程_基于Windows的编程_第22章重叠I/O模型

22.1 理解重叠 I/O 模型 第21章异步处理的并非I/O, 而是"通知". 本章讲解的才是以异步方式处理 I/O 的方法. 只有理解了二者的区别和各自的优势, 才能更轻松地学习第23章的 IOCP. 重叠 I/O 其实各位对于重叠 I/O 并不陌生. 大家已经掌握了异步 I/O. 我通过图21-2说明过异步I/O模型, 实际上, 这种异步 I/O 就相当于 重叠I/O. 下面我将给出重叠I/O, 各位可自行判断二者是否相似. 图22-1 给出重叠 I/O 的原理. 如图22-1 所示, 同一线程内.

weifc-wei 的博客 364

I/O模型简述

http://www.tianxiaobo.com/2018/02/08/IO%E6%A8%A1%E5%9E%8B%E7%AE%80%E8%BF%B0/ 1. 前言 最近在学习 Java NIO 方面的知识,为了加深理解。特地去看了 Unix/Linux I/O 方面的知识,并写了一些代码进行验证。在本文接下来的一章中,我将通过举例的方式向大家介绍五种 I/O 模型。如果大家是第一次了解 I...

1 283

unix网络编程_UNIX 网络编程定义的5种I/O模型

I/O(英语:Input/Output),即输入/输出,通常指数据在存储器(内部和外部)或其他周边设备之间的输入和输出,是信息处理系统(例如计算机)与外部世界(可能是人类或另一信息处理系统)之间的通信。输入是系统接收的信号或数据,输出则是从其发送的信号或数据。参考上图,简单概括:处理器访问任何寄存器和 Cache 等封装以外的数据资源都可以当成 I/O 操作,包括内存,磁盘,显卡等外部设备。UNI...

weixin_39886619的博客 108

Java I/O相关知识(BIO、NIO、AIO)

Java I/O一:Unix I/O模型二:Java I/O模型 一:Unix I/O模型 Linux的内核将所有外部设备都看做一个文件来操作,对一个文件的读写操作会调用内核提供的系统命令,返回一个file descriptor (fd,文件描述符)。而对一个 socket 的读写也会有相应的描述符,称之为 socket fd (socket描述符)。描述符就是一个数字,它指向内核中的一个结构体(文件路径,数据区等一些属性)。 根据UNIX网络编程对I/O模型的分类,UNIX提供了5种I/O模型:阻塞I/O

小小本科生 999
上一篇: 《TCP/IP网络编程》学习笔记 | Chapter 20:Windows 中的线程同步
下一篇: 《TCP/IP网络编程》学习笔记 | Chapter 22:重叠 I/O 模型
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、付费专栏及课程。

余额充值