基于重叠 I/O 模型的通信程序设计:斐波那契数列查询系统

基于重叠 I/O 模型的通信程序设计:斐波那契数列查询系统

关键词:Win32、Winsock2、重叠 I/O (Overlapped I/O)、WSAOVERLAPPED、TCP、长度前缀协议、斐波那契数列


一、实验目的

本实验使用 Win32 API 和 Winsock 2 编写图形化 TCP 客户端与服务器程序。客户端向服务器发送“请输出 1000 以内斐波那契数列”,服务器计算并返回结果。程序使用重叠 I/O 完成连接后的数据收发,并通过工作线程执行网络操作,使窗口线程能够继续处理界面消息。

本实验的目标如下:

  1. 掌握 Winsock 初始化、套接字创建、绑定、监听、连接、收发和资源释放的基本步骤。
  2. 理解 WSAOVERLAPPED、WSASend、WSARecv 和事件对象在重叠 I/O 中的作用。
  3. 掌握 TCP 字节流的消息边界处理方法,以及部分发送、分段接收和长度校验。
  4. 实现客户端请求、服务器端计算、结果响应的完整通信。
  5. 使用并发压力测试检查服务器在连接上限以内和超出连接上限时的行为。

二、实验内容与设计思想

2.1 实验内容

客户端连接服务器后发送请求文本“请输出1000以内斐波那契数列”。服务器接收并校验请求,计算不大于1000的斐波那契数列,并将结果返回客户端。服务器和客户端均采用 Win32 窗口界面;网络操作在线程中执行,运行信息通过窗口日志显示。

斐波那契数列定义如下:

\[\begin{align*} F_0 &= 0 \quad (2.1.1) \\ F_1 &= 1 \quad (2.1.2) \\ F_n &= F_{n-1} + F_{n-2}, \quad n \ge 2 \quad (2.1.3) \end{align*} \]

本实验将“1000以内”解释为数值不超过1000,即输出满足 (F_n \le 1000) 的全部项:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987
下一项为 1597,因为 (1597 > 1000),所以不输出。

为了说明本实验的模块组成和代码文件之间的调用关系,表1列出各文件的主要职责。

表1 程序文件及功能

文件 主要功能
common.h 定义通信常量、请求文本、重叠收发函数、长度前缀帧处理函数和字符集转换函数
fibonacci_algorithm.h 生成不超过指定上限的斐波那契数列
server.cpp 创建服务器窗口、监听连接、管理多个客户端、调用算法并返回结果
client.cpp 创建客户端窗口、读取通信参数、连接服务器、发送请求并显示响应
stress_test.py 使用 Windows Proactor/IOCP 重叠套接字创建并发客户端,验证服务器响应和连接边界

系统结构由客户端窗口、客户端工作线程、公共通信模块、服务器监听线程、服务器客户端工作线程和算法模块组成。图1展示各模块之间的调用关系,以及请求与响应的传递方向。

图1系统结构图:客户端与服务器架构流程

2.2 通信地址与连接参数

服务器默认监听 192.168.50.1,客户端默认连接 192.168.50.1:1145,客户端本地 IPv4 默认设置为 192.168.50.2。客户端本地地址可以留空,由操作系统选择网络接口。表2列出程序的默认网络参数。

表2 默认通信配置

项目 配置
网络层协议 IPv4
传输层协议 TCP
默认服务器监听地址 192.168.50.1
默认客户端连接地址 192.168.50.1
默认客户端本地地址 192.168.50.2, 也可留空
默认服务器端口 1145
正文编码 UTF-8
正文长度上限 8192 字节
应用层数据帧 4 字节网络序长度字段 + 正文
服务器活动客户端上限 128

服务器活动客户端上限由 common.h 中的 MAX_CLIENTS=128 定义。此值限制服务器当前维护的活动客户端连接数,不等同于 listen() 所使用的等待队列长度。

2.3 应用层数据帧设计

TCP 传输连续字节流,不保留应用层消息边界。一次发送的数据可能分多次接收,因此程序使用四字节长度前缀标记正文边界。

表3 应用层数据帧格式

字段 长度 编码形式 作用
PayloadLength 4 字节 无符号整数,网络字节序 表示后续正文的字节数
Payload 0~8192 字节 UTF-8 保存请求文本或响应正文

设正文为 (P),UTF-8 编码后的字节长度为 (L),则数据帧定义为:

\[L = |UTF8(P)| \quad (2.1.4) \]

\[F = BE32(L) \parallel UTF8(P) \quad (2.1.5) \]

\[|F| = 4 + L, \quad 0 \le L \le 8192 \quad (2.1.6) \]

其中,\(BE32\) 表示四字节大端编码,\(\parallel\) 表示字节序列拼接。发送端使用 htonl() 转换长度字段,接收端使用 ntohl() 还原长度。网络帧正文不含 C 字符串结束符;接收函数仅在本地缓冲区末尾增加 '\0',以便执行字符串比较和显示。

2.4 斐波那契数列计算流程

算法从 previous=0、current=1 开始。当 previous 不大于指定上限时,将该项写入结果字符串,然后计算下一项并更新状态;当当前项大于上限时,停止迭代。图2展示了算法的初始化、循环判断、递推更新和结果输出步骤。

图2斐波那契数列生成算法流程图

算法的递推和停止条件为:
若 \(F_n \le 1000\),则输出 \(F_n\)

\[F_{n+1} = F_n + F_{n-1} \]

当 (F_n > 1000) 时停止。
本实验中:(610 + 987 = 1597 > 1000),因此,987是结果中的最后一项。

2.5 服务器端工作流程

服务器窗口允许用户输入监听 IPv4 地址和端口。点击“启动监听”后,程序创建监听套接字,并在线程中执行地址绑定、监听和 accept()。每个客户端接入后,服务器为其创建独立工作线程。工作线程接收完整请求帧、调用计算函数并发送响应帧。图3展示服务器从启动监听到处理多个客户端连接的过程。

图3服务器端流程图:启动、接入与客户端处理

服务器接入连接时,在临界区保护下检查 g_clientCount。若活动连接数已经达到 MAX_CLIENTS,服务器关闭新连接并写入日志;否则将套接字加入客户端数组并创建客户端工作线程。该工作线程处理一条连接的一次请求—响应事务,处理完成后关闭套接字并从活动连接表中移除。

2.6 客户端工作流程

客户端窗口提供服务器 IPv4、服务器端口和可选的本地 IPv4 输入框。点击“连接并查询”后,窗口函数检查输入参数并启动客户端工作线程。工作线程创建套接字、可选绑定本地地址、连接服务器、发送请求帧、接收响应帧,并通过窗口消息更新日志。图4展示客户端的操作流程。

图4客户端流程图:连接与重试流程

客户端请求正文固定为“请输出1000以内斐波那契数列”。客户端发送的是该文本的 UTF-8 字节和对应长度字段。服务器响应到达后,客户端将 UTF-8 文本转换为 Unicode 字符串,再显示在 Win32 日志控件中。

2.7 双向数据传递流程

客户端到服务器的方向传输请求帧,服务器到客户端的方向传输计算结果帧,两者使用同一条已建立的 TCP 连接。图5以双泳道图展示双方各阶段的职责和数据流向。

图5客户端服务器 TCP 通信流程图

一次成功的事务可表示为:
建立连接 -> 客户端发送请求帧 -> 服务器接收与校验 -> 服务器计算 -> 服务器发送响应帧 -> 客户端
服务器发送函数完成,表示数据已由本端提交到 TCP;客户端接收完整长度字段和正文后,才能确认应用层响应完整到达。


三、实验使用环境

  • 操作系统:Microsoft Windows 7/8/10/11
  • 编程环境:Visual C++ 6.0
  • 编译工具:MinGW (g++)

四、实验步骤和调试过程

4.1 文件准备与编译

将 common.h、fibonacci_algorithm.h、server.cpp、client.cpp 和 stress_test.py 放在同一项目目录。服务器和客户端分别编译成独立的图形界面程序;算法文件和公共头文件通过 #include 被服务器或客户端调用。

本次编译使用以下命令:

g++ -std=c++98 -pedantic -Wall -Wextra -Werror -O2 -finput-charset=UTF-8 -fexec-charset=UTF-8 -mwindows -o server.exe server.cpp -lws2_32 -luser32 -lgdi32
g++ -std=c++98 -pedantic -Wall -Wextra -Werror -O2 -finput-charset=UTF-8 -fexec-charset=UTF-8 -mwindows -o client.exe client.cpp -lws2_32 -luser32 -lgdi32

其中,-mwindows 用于构建 Windows 图形界面程序;-lws2_32 链接 Winsock;-luser32 和 -lgdi32 链接 Win32 窗口接口;UTF-8 参数用于统一源文件和执行字符集;-Werror 将编译警告视为错误。编译结果如图6所示。

图片6

4.2 common.h 公共模块详解

common.h 是服务器和客户端共享的通信基础模块。其功能由常量、初始化函数、字符转换函数、重叠传输函数和数据帧函数组成。

  • MAX_MESSAGE_SIZE:定义正文最大长度为8192字节。长度字段本身不计入正文容量。
  • MAX_CLIENTS:定义服务器同时维护的活动客户端上限为128。
  • DEFAULT_PORT:定义默认服务器端口 1145。
  • CLIENT_REQUEST:定义客户端需要发送的固定 UTF-8 文本。
  • #pragma comment:仅对 MSVC 编译器生效,用于提示链接 Winsock 和 Win32 图形库。MinGW 编译时由命令行中的 -l 参数链接相应库。

InitializeWinsock():调用 WSAStartup(MAKEWORD(2,2), &data) 初始化 Winsock 2.2。若初始化成功,返回 true;若返回非零错误码,则返回 false。

Utf8ToWide():将以 UTF-8 编码的窄字符文本转换为 Windows 宽字符文本,调用 MultiByteToWideChar(CP_UTF8, ...) 完成转换。

WideToUtf8():将 Win32 窗口控件读取到的宽字符输入转换为 UTF-8。调用 WideCharToMultiByte(CP_UTF8, ...)。

TransferOverlapped():本项目重叠 I/O 的核心实现。参数分别表示套接字、数据缓冲区、需要传输的字节数以及操作方向 sending。

  • 每次循环创建 WSAOVERLAPPED、WSABUF 和传输计数变量。
  • 清零 WSAOVERLAPPED 结构,并调用 WSACreateEvent() 创建事件对象,将句柄写入 overlapped.hEvent。
  • 根据 sending 选择调用 WSASend() 或 WSARecv()。
  • 若调用返回 SOCKET_ERROR,读取错误码。WSA_IO_PENDING 表示操作尚未完成,函数继续等待。
  • 调用 WSAGetOverlappedResult(..., TRUE, ...) 等待操作完成,并取得实际传输的字节数。
  • 将实际传输字节数加入 offset。若仍有未传输的数据,则继续循环;全部完成后返回成功。

SendFrame() / ReceiveFrame():发送和接收一条完整应用层数据帧。先处理四字节长度字段,再处理正文。ReceiveFrame 会检查正文是否超过协议最大长度,防止缓冲区越界。

点击展开/收起:common.h 完整代码
#ifndef FIBONACCI_COMMON_H
#define FIBONACCI_COMMON_H

// 公共模块: Winsock 初始化、长度前缀协议、重叠收发和窗口日志转换。
#include <winsock2.h>
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#ifdef _MSC_VER
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdi32.lib")
#endif
const int MAX_MESSAGE_SIZE = 8192;
const int MAX_CLIENTS = 128;
const unsigned short DEFAULT_PORT = 1145;
const char CLIENT_REQUEST[] = "请输出 1000 以内斐波那契数列";

inline bool InitializeWinsock()
{
    WSADATA data;
    int result = WSAStartup(MAKEWORD(2, 2), &data);
    if (result != 0)
        return false;
    return true;
}

// GUI 使用 Unicode 控件;网络协议正文使用 UTF-8,因此两者之间显式转换。
inline void Utf8ToWide(const char *input, wchar_t *output, int capacity)
{
    if (capacity <= 0) return;
    output[0] = L'\0';
    MultiByteToWideChar(CP_UTF8, 0, input, -1, output, capacity);
}

inline void WideToUtf8(const wchar_t *input, char *output, int capacity)
{
    if (capacity <= 0) return;
    output[0] = '\0';
    WideCharToMultiByte(CP_UTF8, 0, input, -1, output, capacity, NULL, NULL);
}

// 用真正的 WSAOVERLAPPED 结构提交操作,并通过事件等待该次操作完成。
// TCP 可能部分传输,因此循环推进 offset,直到指定长度全部完成。
inline bool TransferOverlapped(SOCKET socketHandle, char *data, int length, bool sending)
{
    int offset = 0;
    while (offset < length)
    {
        WSAOVERLAPPED overlapped;
        WSABUF buffer;
        DWORD transferred = 0;
        DWORD flags = 0;
        memset(&overlapped, 0, sizeof(overlapped));
        overlapped.hEvent = WSACreateEvent();
        if (overlapped.hEvent == WSA_INVALID_EVENT)
            return false;
        buffer.buf = data + offset;
        buffer.len = (ULONG)(length - offset);
        int result = sending
            ? WSASend(socketHandle, &buffer, 1, &transferred, 0, &overlapped, NULL)
            : WSARecv(socketHandle, &buffer, 1, &transferred, &flags, &overlapped, NULL);
        if (result == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING)
        {
            WSACloseEvent(overlapped.hEvent);
            return false;
        }
        if (WSAGetOverlappedResult(socketHandle, &overlapped, &transferred, TRUE, &flags) == FALSE)
        {
            WSACloseEvent(overlapped.hEvent);
            return false;
        }
        WSACloseEvent(overlapped.hEvent);
        if (transferred == 0)
            return false;
        offset += (int)transferred;
    }
    return true;
}

inline bool SendFrame(SOCKET socketHandle, const char *payload, int length)
{
    if (length < 0 || length > MAX_MESSAGE_SIZE)
        return false;
    unsigned long netLength = htonl((u_long)length);
    if (!TransferOverlapped(socketHandle, (char *)&netLength, 4, true))
        return false;
    return length == 0 || TransferOverlapped(socketHandle, (char *)payload, length, true);
}

inline bool ReceiveFrame(SOCKET socketHandle, char *payload, int capacity, int *lengthOut)
{
    unsigned long netLength = 0;
    if (!TransferOverlapped(socketHandle, (char *)&netLength, 4, false))
        return false;
    unsigned long length = ntohl(netLength);
    if (length > (unsigned long)MAX_MESSAGE_SIZE || length >= (unsigned long)capacity)
        return false;
    if (length > 0 && !TransferOverlapped(socketHandle, payload, (int)length, false))
        return false;
    payload[length] = '\0';
    *lengthOut = (int)length;
    return true;
}

#endif

4.3 fibonacci_algorithm.h 斐波那契算法模块详解

该文件将数学计算与网络通信分离,只包含斐波那契数列生成函数 BuildFibonacciSequence()。

  • 输入参数检查,将 output[0] 设置为空字符。
  • 状态变量初始化:previous=0,current=1,used=0。
  • 上限循环:只要 previous <= limit,函数就格式化并追加该项。
  • 缓冲区容量检查,预留一个字节给最终字符串结束符。
  • 完成返回:当 previous 超过上限时,循环结束并返回 true。

本实验上限为 1000,最后输出项为 987,下一项为 1597。此数值范围不会导致 unsigned long 溢出。

点击展开/收起:fibonacci_algorithm.h 完整代码
#ifndef FIBONACCI_ALGORITHM_H
#define FIBONACCI_ALGORITHM_H

// 生成所有不大于 limit 的斐波那契数,结果以空格分隔写入 output。
// 本实验 limit 为 1000,序列末项为 987;使用 unsigned long 足以保存。
inline bool BuildFibonacciSequence(unsigned long limit, char *output, int capacity)
{
    if (output == NULL || capacity <= 0)
        return false;

    output[0] = '\0';
    unsigned long previous = 0; // F0
    unsigned long current = 1; // F1
    int used = 0;

    while (previous <= limit)
    {
        char number[32];
        // 将当前项格式化为十进制文本。
        sprintf(number, "%lu", previous);
        int length = (int)strlen(number);
        int separator = (used == 0) ? 0 : 1;
        if (used + separator + length >= capacity)
            return false; // 预留一个字节给字符串末尾的 '\0'.
        if (separator)
            output[used++] = ' ';
        memcpy(output + used, number, length);
        used += length;
        output[used] = '\0';

        // 下一项超出 unsigned long 范围或超过 limit 时结束;本实验不会溢出。
        unsigned long next = previous + current;
        previous = current;
        current = next;
    }
    return true;
}

#endif // FIBONACCI_ALGORITHM_H

4.4 server.cpp 服务器端程序详解

服务器端代码由共享状态、日志函数、客户端线程、监听线程、停止逻辑、控件创建函数、窗口过程和程序入口构成。

  • WM_APPEND_LOG 定义自定义窗口消息,用于将工作线程产生的日志安全地传递到窗口线程。
  • PostLog(message) 函数供监听线程和客户端工作线程调用,通过 PostMessageW() 发送消息。
  • RemoveClient(socketHandle) 在临界区内遍历客户端数组,查找指定套接字并清理。
  • ClientWorker(parameter) 处理该连接的一次请求—响应事务,调用 BuildFibonacciSequence 等。
  • AcceptWorker(parameter) 负责创建监听套接字、绑定地址、开始监听和接受连接。
  • StopServer() 响应停止按钮或窗口关闭操作,原子清除 g_running 并使套接字失效。
  • WindowProc() 处理窗口消息和用户操作。
点击展开/收起:server.cpp 完整代码
// Win32 图形服务器。accept 在监听线程中执行,每个已连接客户端由独立线程处理;
// 每条连接的实际数据收发均通过公共头文件中的 WSAOVERLAPPED 函数完成。
#include "common.h"
#include "fibonacci_algorithm.h"

#define ID_BIND_IP 101
#define ID_PORT 102
#define ID_START 103
#define ID_STOP 104
#define ID_LOG 105
#define WM_APPEND_LOG (WM_APP + 1)

static HWND g_window = NULL;
static HWND g_log = NULL;
static volatile LONG g_running = 0;
static SOCKET g_listener = INVALID_SOCKET;
static CRITICAL_SECTION g_clientLock;
static SOCKET g_clients[MAX_CLIENTS];
static int g_clientCount = 0;
static HANDLE g_acceptThread = NULL;
static LONG g_workerCount = 0;
// 与实验报告的回环网卡配置一致,服务器默认绑定实验服务器地址。
static char g_bindIp[64] = "192.168.50.1";
static unsigned short g_port = DEFAULT_PORT;

static void PostLog(const char *message)
{
    int bytes = (int)strlen(message) + 1;
    char *copy = (char *)malloc(bytes);
    if (copy == NULL) return;
    memcpy(copy, message, bytes);
    if (!PostMessageW(g_window, WM_APPEND_LOG, 0, (LPARAM)copy))
        free(copy);
}

static void RemoveClient(SOCKET socketHandle)
{
    int i;
    EnterCriticalSection(&g_clientLock);
    for (i = 0; i < g_clientCount; ++i)
    {
        if (g_clients[i] == socketHandle)
        {
            g_clients[i] = g_clients[g_clientCount - 1];
            --g_clientCount;
            break;
        }
    }
    LeaveCriticalSection(&g_clientLock);
}

static DWORD WINAPI ClientWorker(LPVOID parameter)
{
    SOCKET client = (SOCKET)(UINT_PTR)parameter;
    char request[MAX_MESSAGE_SIZE + 1];
    char reply[MAX_MESSAGE_SIZE + 1];
    int requestLength = 0;
    bool ok = ReceiveFrame(client, request, sizeof(request), &requestLength);

    if (ok && requestLength == (int)strlen(CLIENT_REQUEST) && strcmp(request, CLIENT_REQUEST) == 0)
    {
        if (BuildFibonacciSequence(1000, reply, sizeof(reply)))
        {
            char line[MAX_MESSAGE_SIZE + 128];
            sprintf(line, "客户端请求已处理,结果:%s", reply);
            PostLog(line);
            ok = SendFrame(client, reply, (int)strlen(reply));
        }
        else
        {
            const char errorText[] = "服务器生成结果失败";
            ok = SendFrame(client, errorText, (int)strlen(errorText));
        }
    }
    else if (ok)
    {
        const char errorText[] = "不支持的请求:请发送规定的斐波那契数列请求";
        ok = SendFrame(client, errorText, (int)strlen(errorText));
        PostLog("收到不支持的客户端请求,已返回错误说明。");
    }
    shutdown(client, SD_BOTH);
    closesocket(client);
    RemoveClient(client);
    InterlockedDecrement(&g_workerCount);
    (void)ok;
    return 0;
}

static DWORD WINAPI AcceptWorker(LPVOID)
{
    SOCKET listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (listener == INVALID_SOCKET)
    {
        PostLog("创建监听套接字失败。");
        InterlockedExchange(&g_running, 0);
        return 1;
    }
    g_listener = listener;
    sockaddr_in address;
    memset(&address, 0, sizeof(address));
    address.sin_family = AF_INET;
    address.sin_port = htons(g_port);
    address.sin_addr.s_addr = inet_addr(g_bindIp);

    if (address.sin_addr.s_addr == INADDR_NONE && strcmp(g_bindIp, "255.255.255.255") != 0)
    {
        PostLog("监听地址格式无效,请输入 IPv4 地址或 0.0.0.0。");
        closesocket(listener);
        g_listener = INVALID_SOCKET;
        InterlockedExchange(&g_running, 0);
        return 1;
    }
    if (bind(listener, (sockaddr *)&address, sizeof(address)) == SOCKET_ERROR ||
        listen(listener, SOMAXCONN) == SOCKET_ERROR)
    {
        char errorText[192];
        sprintf(errorText, "绑定或监听失败(Winsock 错误码 %d);请确认本机已配置 %s 且端口 %u 未被占用。",
                WSAGetLastError(), g_bindIp, (unsigned int)g_port);
        PostLog(errorText);
        closesocket(listener);
        g_listener = INVALID_SOCKET;
        InterlockedExchange(&g_running, 0);
        return 1;
    }
    char status[160];
    sprintf(status, "服务器正在监听 %s:%u,可接受多个客户端。", g_bindIp, (unsigned int)g_port);
    PostLog(status);

    while (InterlockedCompareExchange(&g_running, 1, 1) == 1)
    {
        SOCKET client = accept(listener, NULL, NULL);
        if (client == INVALID_SOCKET)
        {
            if (InterlockedCompareExchange(&g_running, 1, 1) == 1)
                PostLog("accept 接受连接失败;服务器继续等待后续连接。");
            break;
        }
        EnterCriticalSection(&g_clientLock);
        bool room = g_clientCount < MAX_CLIENTS;
        if (room)
            g_clients[g_clientCount++] = client;
        LeaveCriticalSection(&g_clientLock);

        if (!room)
        {
            PostLog("当前客户端数已达到上限,新连接已拒绝。");
            closesocket(client);
            continue;
        }
        InterlockedIncrement(&g_workerCount);
        HANDLE thread = CreateThread(NULL, 0, ClientWorker, (LPVOID)(UINT_PTR)client, 0, NULL);
        if (thread == NULL)
        {
            RemoveClient(client);
            closesocket(client);
            InterlockedDecrement(&g_workerCount);
            PostLog("无法为新客户端创建处理线程。");
        }
        else
        {
            CloseHandle(thread);
            PostLog("新的客户端已连接,已分配独立处理线程。");
        }
    }
    if (g_listener == listener)
    {
        g_listener = INVALID_SOCKET;
        closesocket(listener);
    }
    PostLog("监听线程已停止。");
    return 0;
}

static void StopServer()
{
    InterlockedExchange(&g_running, 0);
    SOCKET listener = g_listener;
    if (listener != INVALID_SOCKET)
    {
        shutdown(listener, SD_BOTH);
        closesocket(listener); // 关闭监听套接字以解除 accept 阻塞。
        g_listener = INVALID_SOCKET;
    }
    if (g_acceptThread != NULL)
    {
        WaitForSingleObject(g_acceptThread, 3000);
        CloseHandle(g_acceptThread);
        g_acceptThread = NULL;
    }
    EnterCriticalSection(&g_clientLock);
    int i;
    for (i = 0; i < g_clientCount; ++i)
        shutdown(g_clients[i], SD_BOTH); // 唤醒正在等待重叠接收的客户端线程。
    LeaveCriticalSection(&g_clientLock);
}

static void AddControl(HWND parent, const wchar_t *klass, const wchar_t *text,
                       DWORD style, int x, int y, int width, int height, int id)
{
    CreateWindowExW(0, klass, text, WS_CHILD | WS_VISIBLE | style,
        x, y, width, height, parent, (HMENU)(INT_PTR)id,
        (HINSTANCE)GetWindowLongPtrW(parent, GWLP_HINSTANCE), NULL);
}

static LRESULT CALLBACK WindowProc(HWND window, UINT message, WPARAM wParam, LPARAM lParam)
{
    if (message == WM_APPEND_LOG)
    {
        char *utf8 = (char *)lParam;
        wchar_t wide[2048];
        Utf8ToWide(utf8, wide, 2048);
        int end = GetWindowTextLengthW(g_log);
        SendMessageW(g_log, EM_SETSEL, end, end);
        SendMessageW(g_log, EM_REPLACESEL, FALSE, (LPARAM)wide);
        free(utf8);
        return 0;
    }
    if (message == WM_COMMAND)
    {
        if (LOWORD(wParam) == ID_START && InterlockedCompareExchange(&g_running, 1, 0) == 0)
        {
            wchar_t wideIp[128], widePort[32];
            GetWindowTextW(GetDlgItem(window, ID_BIND_IP), wideIp, 128);
            GetWindowTextW(GetDlgItem(window, ID_PORT), widePort, 32);
            WideToUtf8(wideIp, g_bindIp, sizeof(g_bindIp));
            int port = _wtoi(widePort);
            if (port < 1 || port > 65535)
            {
                InterlockedExchange(&g_running, 0);
                MessageBoxW(window, L"端口范围必须为 1 到 65535。", L"参数错误", MB_OK | MB_ICONWARNING);
                return 0;
            }
            g_port = (unsigned short)port;
            g_acceptThread = CreateThread(NULL, 0, AcceptWorker, NULL, 0, NULL);
            if (g_acceptThread == NULL)
            {
                InterlockedExchange(&g_running, 0);
                MessageBoxW(window, L"无法创建服务器监听线程。", L"启动失败", MB_OK | MB_ICONERROR);
            }
        }
        else if (LOWORD(wParam) == ID_STOP)
            StopServer();
        return 0;
    }
    if (message == WM_CLOSE)
    {
        StopServer();
        if (g_acceptThread != NULL)
        {
            WaitForSingleObject(g_acceptThread, 3000);
            CloseHandle(g_acceptThread);
            g_acceptThread = NULL;
        }
        while (InterlockedCompareExchange(&g_workerCount, 0, 0) > 0)
            Sleep(10);
        DestroyWindow(window);
        return 0;
    }
    if (message == WM_DESTROY)
    {
        WSACleanup();
        DeleteCriticalSection(&g_clientLock);
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProcW(window, message, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE instance, HINSTANCE, LPSTR, int showCommand)
{
    if (!InitializeWinsock())
    {
        MessageBoxW(NULL, L"Winsock 初始化失败。", L"错误", MB_OK | MB_ICONERROR);
        return 1;
    }
    InitializeCriticalSection(&g_clientLock);
    WNDCLASSW wc;
    memset(&wc, 0, sizeof(wc));
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = instance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszClassName = L"OverlappedFibonacciServer";
    RegisterClassW(&wc);

    g_window = CreateWindowW(wc.lpszClassName, L"重叠 I/O 斐波那契服务器",
        WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 720, 520,
        NULL, NULL, instance, NULL);
    if (g_window == NULL) { WSACleanup(); DeleteCriticalSection(&g_clientLock); return 1; }

    AddControl(g_window, L"STATIC", L"监听 IPv4: ", 0, 20, 20, 90, 24, 0);
    AddControl(g_window, L"EDIT", L"192.168.50.1", WS_BORDER | ES_AUTOHSCROLL, 110, 18, 180, 26, ID_BIND_IP);
    AddControl(g_window, L"STATIC", L"端口: ", 0, 310, 20, 50, 24, 0);
    AddControl(g_window, L"EDIT", L"1145", WS_BORDER | ES_NUMBER, 360, 18, 90, 26, ID_PORT);
    AddControl(g_window, L"BUTTON", L"启动监听", BS_PUSHBUTTON, 470, 18, 100, 28, ID_START);
    AddControl(g_window, L"BUTTON", L"停止服务器", BS_PUSHBUTTON, 580, 18, 110, 28, ID_STOP);
    AddControl(g_window, L"STATIC", L"运行日志: ", 0, 20, 62, 100, 24, 0);
    g_log = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"", WS_CHILD | WS_VISIBLE |
        ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY | WS_VSCROLL,
        20, 90, 670, 370, g_window, (HMENU)(INT_PTR)ID_LOG, instance, NULL);

    ShowWindow(g_window, showCommand);
    UpdateWindow(g_window);

    MSG msg;
    while (GetMessageW(&msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&msg);
        DispatchMessageW(&msg);
    }
    return (int)msg.wParam;
}

4.5 client.cpp 客户端程序详解

客户端代码由控件标识符、线程状态、日志函数、客户端线程、控件创建函数、窗口过程和程序入口构成。

  • ClientWorker 依次完成套接字建立、连接、数据帧收发和资源释放。
  • SendFrame() 发送固定请求正文,长度取 UTF-8 编码后的字节长度。
  • ReceiveFrame() 接收完整响应帧,成功后将响应从 UTF-8 转换为 Unicode 并投递到窗口日志。
  • connect() 在工作线程中执行,不是重叠连接操作;连接之后的请求和响应数据由公共模块的重叠 I/O 函数处理。
点击展开/收起:client.cpp 完整代码
// Win32 图形客户端。网络连接放在工作线程中,窗口线程始终负责响应界面消息。
// 请求与响应正文使用 UTF-8,收发使用公共模块中的 WSAOVERLAPPED 数据帧函数。
#include "common.h"

#define ID_SERVER_IP 201
#define ID_SERVER_PORT 202
#define ID_LOCAL_IP 203
#define ID_CONNECT 204
#define ID_LOG 205
#define WM_APPEND_LOG (WM_APP + 1)

static HWND g_window = NULL;
static HWND g_log = NULL;
static HANDLE g_clientThread = NULL;
static volatile LONG g_busy = 0;
static volatile LONG g_cancel = 0;
static SOCKET g_socket = INVALID_SOCKET;
static char g_serverIp[64];
static char g_localIp[64];
static unsigned short g_port;

static void PostLog(const char *message)
{
    int bytes = (int)strlen(message) + 1;
    char *copy = (char *)malloc(bytes);
    if (copy == NULL) return;
    memcpy(copy, message, bytes);
    if (!PostMessageW(g_window, WM_APPEND_LOG, 0, (LPARAM)copy))
        free(copy);
}

static DWORD WINAPI ClientWorker(LPVOID)
{
    SOCKET socketHandle = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (socketHandle == INVALID_SOCKET)
    {
        PostLog("创建客户端套接字失败。");
        InterlockedExchange(&g_busy, 0);
        return 1;
    }
    g_socket = socketHandle;

    // 本地地址允许留空; 非空时 bind 到用户指定的 IPv4 地址和临时端口。
    if (g_localIp[0] != '\0')
    {
        sockaddr_in localAddress;
        memset(&localAddress, 0, sizeof(localAddress));
        localAddress.sin_family = AF_INET;
        localAddress.sin_addr.s_addr = inet_addr(g_localIp);
        localAddress.sin_port = 0;
        if (localAddress.sin_addr.s_addr == INADDR_NONE ||
            bind(socketHandle, (sockaddr *)&localAddress, sizeof(localAddress)) == SOCKET_ERROR)
        {
            char errorText[192];
            sprintf(errorText, "客户端本地地址 %s 无效或绑定失败 (Winsock 错误码 %d) ; 请留空或填写本机已有 IPv4 地址。",
                    g_localIp, WSAGetLastError());
            PostLog(errorText);
            closesocket(socketHandle);
            g_socket = INVALID_SOCKET;
            InterlockedExchange(&g_busy, 0);
            return 1;
        }
    }

    sockaddr_in serverAddress;
    memset(&serverAddress, 0, sizeof(serverAddress));
    serverAddress.sin_family = AF_INET;
    serverAddress.sin_port = htons(g_port);
    serverAddress.sin_addr.s_addr = inet_addr(g_serverIp);

    if (serverAddress.sin_addr.s_addr == INADDR_NONE ||
        connect(socketHandle, (sockaddr *)&serverAddress, sizeof(serverAddress)) == SOCKET_ERROR)
    {
        char errorText[192];
        sprintf(errorText, "连接服务器 %s:%u 失败 (Winsock 错误码 %d)。",
                g_serverIp, (unsigned int)g_port, WSAGetLastError());
        PostLog(errorText);
        closesocket(socketHandle);
        g_socket = INVALID_SOCKET;
        InterlockedExchange(&g_busy, 0);
        return 1;
    }

    char message[256];
    sprintf(message, "已连接服务器 %s:%u", g_serverIp, (unsigned int)g_port);
    PostLog(message);

    if (InterlockedCompareExchange(&g_cancel, 0, 0) == 0 &&
        SendFrame(socketHandle, CLIENT_REQUEST, (int)strlen(CLIENT_REQUEST)))
    {
        PostLog("请求已发送: 请输出 1000 以内斐波那契数列");
        char reply[MAX_MESSAGE_SIZE + 1];
        int replyLength = 0;
        if (ReceiveFrame(socketHandle, reply, sizeof(reply), &replyLength))
        {
            // 响应是以 UTF-8 编码的完整正文,转换后放入 Unicode 编辑器。
            wchar_t wideReply[MAX_MESSAGE_SIZE + 1];
            Utf8ToWide(reply, wideReply, MAX_MESSAGE_SIZE + 1);
            int bytes = WideCharToMultiByte(CP_UTF8, 0, wideReply, -1, NULL, 0, NULL, NULL);
            char *utf8Reply = (char *)malloc(bytes + 1);
            if (utf8Reply != NULL)
            {
                WideCharToMultiByte(CP_UTF8, 0, wideReply, -1, utf8Reply, bytes, NULL, NULL);
                sprintf(message, "服务器返回: %s", utf8Reply);
                PostLog(message);
                free(utf8Reply);
            }
            (void)replyLength;
        }
        else if (InterlockedCompareExchange(&g_cancel, 0, 0) == 0)
        {
            PostLog("接收服务器响应失败或连接已关闭。");
        }
    }
    else if (InterlockedCompareExchange(&g_cancel, 0, 0) == 0)
    {
        PostLog("发送请求失败。");
    }

    shutdown(socketHandle, SD_BOTH);
    closesocket(socketHandle);
    g_socket = INVALID_SOCKET;
    InterlockedExchange(&g_busy, 0);
    PostLog("本次查询结束; 可修改地址后再次连接。");
    return 0;
}

static void AddControl(HWND parent, const wchar_t *klass, const wchar_t *text,
                       DWORD style, int x, int y, int width, int height, int id)
{
    CreateWindowExW(0, klass, text, WS_CHILD | WS_VISIBLE | style,
        x, y, width, height, parent, (HMENU)(INT_PTR)id,
        (HINSTANCE)GetWindowLongPtrW(parent, GWLP_HINSTANCE), NULL);
}

static LRESULT CALLBACK WindowProc(HWND window, UINT message, WPARAM wParam, LPARAM lParam)
{
    if (message == WM_APPEND_LOG)
    {
        char *utf8 = (char *)lParam;
        wchar_t wide[2048];
        Utf8ToWide(utf8, wide, 2048);
        int end = GetWindowTextLengthW(g_log);
        SendMessageW(g_log, EM_SETSEL, end, end);
        SendMessageW(g_log, EM_REPLACESEL, FALSE, (LPARAM)wide);
        free(utf8);
        return 0;
    }
    if (message == WM_COMMAND && LOWORD(wParam) == ID_CONNECT)
    {
        if (InterlockedCompareExchange(&g_busy, 1, 0) != 0)
        {
            MessageBoxW(window, L"当前查询仍在进行中。", L"提示", MB_OK | MB_ICONINFORMATION);
            return 0;
        }
        wchar_t wideIp[128], widePort[32], wideLocal[128];
        GetWindowTextW(GetDlgItem(window, ID_SERVER_IP), wideIp, 128);
        GetWindowTextW(GetDlgItem(window, ID_SERVER_PORT), widePort, 32);
        GetWindowTextW(GetDlgItem(window, ID_LOCAL_IP), wideLocal, 128);
        WideToUtf8(wideIp, g_serverIp, sizeof(g_serverIp));
        WideToUtf8(wideLocal, g_localIp, sizeof(g_localIp));
        int port = _wtoi(widePort);
        if (port < 1 || port > 65535 || g_serverIp[0] == '\0')
        {
            InterlockedExchange(&g_busy, 0);
            MessageBoxW(window, L"请输入有效的服务器 IPv4 地址和 1 到 65535 之间的端口。",
                L"参数错误", MB_OK | MB_ICONWARNING);
            return 0;
        }
        g_port = (unsigned short)port;
        InterlockedExchange(&g_cancel, 0);
        g_clientThread = CreateThread(NULL, 0, ClientWorker, NULL, 0, NULL);
        if (g_clientThread == NULL)
        {
            InterlockedExchange(&g_busy, 0);
            MessageBoxW(window, L"无法创建客户端工作线程。", L"错误", MB_OK | MB_ICONERROR);
        }
        return 0;
    }
    if (message == WM_CLOSE)
    {
        InterlockedExchange(&g_cancel, 1);
        if (g_socket != INVALID_SOCKET)
            shutdown(g_socket, SD_BOTH);
        if (g_clientThread != NULL)
        {
            WaitForSingleObject(g_clientThread, 5000);
            CloseHandle(g_clientThread);
            g_clientThread = NULL;
        }
        DestroyWindow(window);
        return 0;
    }
    if (message == WM_DESTROY)
    {
        WSACleanup();
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProcW(window, message, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE instance, HINSTANCE, LPSTR, int showCommand)
{
    if (!InitializeWinsock())
    {
        MessageBoxW(NULL, L"Winsock 初始化失败。", L"错误", MB_OK | MB_ICONERROR);
        return 1;
    }
    WNDCLASSW wc;
    memset(&wc, 0, sizeof(wc));
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = instance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszClassName = L"OverlappedFibonacciClient";
    RegisterClassW(&wc);

    g_window = CreateWindowW(wc.lpszClassName, L"重叠 I/O 斐波那契客户端",
        WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 720, 520,
        NULL, NULL, instance, NULL);
    if (g_window == NULL) { WSACleanup(); return 1; }

    AddControl(g_window, L"STATIC", L"服务器 IPv4: ", 0, 20, 20, 100, 24, 0);
    AddControl(g_window, L"EDIT", L"192.168.50.1", WS_BORDER | ES_AUTOHSCROLL, 125, 18, 180, 26, ID_SERVER_IP);
    AddControl(g_window, L"STATIC", L"端口: ", 0, 320, 20, 50, 24, 0);
    AddControl(g_window, L"EDIT", L"1145", WS_BORDER | ES_NUMBER, 370, 18, 90, 26, ID_SERVER_PORT);
    AddControl(g_window, L"STATIC", L"本地 IPv4 (可留空) : ", 0, 20, 58, 150, 24, 0);
    AddControl(g_window, L"EDIT", L"192.168.50.2", WS_BORDER | ES_AUTOHSCROLL, 175, 56, 180, 26, ID_LOCAL_IP);
    AddControl(g_window, L"BUTTON", L"连接并查询", BS_PUSHBUTTON, 385, 54, 120, 30, ID_CONNECT);
    AddControl(g_window, L"STATIC", L"运行日志: ", 0, 20, 100, 100, 24, 0);
    g_log = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"", WS_CHILD | WS_VISIBLE |
        ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY | WS_VSCROLL,
        20, 128, 670, 330, g_window, (HMENU)(INT_PTR)ID_LOG, instance, NULL);

    ShowWindow(g_window, showCommand);
    UpdateWindow(g_window);

    MSG msg;
    while (GetMessageW(&msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&msg);
        DispatchMessageW(&msg);
    }
    return (int)msg.wParam;
}

4.6 重叠 I/O 模型在程序中的实现

本实验参考 WSAEventSelect 实验报告的模块划分、图形界面和日志组织方式,但通信模型保持为重叠 I/O。WSAEventSelect 与重叠 I/O 是不同的网络事件机制;当前程序的数据收发不调用 WSAEventSelect()。

重叠 I/O 的主要代码位于 common.h 的 TransferOverlapped() 函数中:

  1. 创建 WSAOVERLAPPED 结构并将其清零。
  2. 为本次操作创建事件对象,并保存到 overlapped.hEvent。
  3. 发送方向调用 WSASend(),接收方向调用 WSARecv(),二者均传入 WSAOVERLAPPED 指针。
  4. 若操作未立即完成,检查 WSAGetLastError() 是否为 WSA_IO_PENDING;该状态表示操作仍在执行,不是最终失败。
  5. 调用 WSAGetOverlappedResult(..., TRUE, ...) 等待操作完成并读取真实传输字节数。
  6. 关闭本次操作的事件对象。
  7. 若只传输了部分数据,按照真实字节数更新偏移量并继续传输;全部完成后函数才返回成功。

图7展示一次重叠 I/O 操作从提交到完成的状态变化,突出待处理状态、完成结果检查和部分传输续作。

图7Windows 重叠 I_O 操作流程图

4.7 stress_test.py 压力测试脚本详解

该脚本用于创建与客户端协议一致的并发测试连接。Windows 下显式使用 asyncio Proactor/IOCP 事件循环,该循环以完成端口和重叠套接字操作实现网络 I/O。

  • open_client():建立一个测试客户端连接。
  • do_transaction():执行一轮请求—响应,生成四字节网络序长度字段并拼接发送。
  • run_round():执行一轮并发测试,通过 asyncio.gather() 并发建立指定数量的连接。
  • main_async():负责运行一个或多个测试档位及多轮测试,输出目标服务器、代码配置上限、轮数、超时和源 IP 配置。
  • read_server_limit():读取与脚本同目录的 common.h,使用正则表达式提取 MAX_CLIENTS 的整数值。

表5 压力测试参数及含义

参数 功能 默认值或处理方式
--connections 设置每轮同时连接数 省略时交互输入;回车选择代码上限
--rounds 重复测试轮数 默认 3
--timeout 设置连接和收发阶段超时 默认 15 秒
--server-limit 覆盖压力脚本使用的服务端上限 默认从 common.h 读取
--boundary-test 自动执行上限和超限两档 超限数量由 --overflow 指定
--overflow 设置边界测试档超过上限的数量 默认 16
--source-ips 指定测试客户端使用的本地 IPv4 地址 逗号分隔并轮流绑定; 地址必须配置在本机
点击展开/收起:stress_test.py 完整代码
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Concurrent stress test for the overlapped-I/O Fibonacci server.

On Windows, asyncio's Proactor event loop uses IOCP/overlapped socket operations.
The script uses the same framing as client.exe: 4-byte network-order length + UTF-8 body.
Each round opens all connections before sending and validates every complete response.
"""
import argparse
import asyncio
import ipaddress
from pathlib import Path
import re
import struct
import sys
import time
from typing import Optional

REQUEST = "请输出 1000 以内斐波那契数列".encode("utf-8")
EXPECTED = "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987"

async def open_client(host: str, port: int, timeout: float, source_ip: Optional[str]):
    try:
        options = {}
        if source_ip:
            # Bind the stress client to the requested local interface address.
            options["local_addr"] = (source_ip, 0)
        reader, writer = await asyncio.wait_for(
            asyncio.open_connection(host, port, **options), timeout=timeout
        )
        return reader, writer, source_ip or "auto", None
    except Exception as exc:  # 连接失败也记录,继续压测其余并发请求。
        source = source_ip if source_ip else "system-selected"
        return None, None, source_ip or "auto", f"source {source}: connect failed: {exc}"

async def do_transaction(reader, writer, timeout: float):
    try:
        writer.write(struct.pack("I", len(REQUEST)) + REQUEST)
        await asyncio.wait_for(writer.drain(), timeout=timeout)
        header = await asyncio.wait_for(reader.readexactly(4), timeout=timeout)
        (length,) = struct.unpack("I", header)
        if length > 8192:
            return False, f"response length {length} exceeds 8192 bytes"
        body = await asyncio.wait_for(reader.readexactly(length), timeout=timeout)
        text = body.decode("utf-8")
        if text != EXPECTED:
            return False, f"unexpected response body: {text}"
        return True, None
    except Exception as exc:
        return False, f"transfer or validation failed: {exc}"

async def run_round(host: str, port: int, count: int, timeout: float, source_ips):
    # 先同时打开全部连接,确保本轮确实测试指定的并发连接数。
    opened = await asyncio.gather(
        *(open_client(host, port, timeout,
                      source_ips[index % len(source_ips)] if source_ips else None)
          for index in range(count))
    )
    active = {(reader, writer, source) for reader, writer, source, error in opened if error is None}
    errors = [error for _, _, _, error in opened if error is not None]

    results = await asyncio.gather(
        *(do_transaction(reader, writer, timeout) for reader, writer, _ in active)
    )
    passed = sum(1 for ok, _ in results if ok)
    errors.extend(
        [f"source {source}: {message}"
         for (_, _, source), (ok, message) in zip(active, results)
         if not ok]
    )
    per_source = {}
    for (_, _, source), (ok, _) in zip(active, results):
        stats = per_source.setdefault(source, {"passed": 0, "failed": 0})
        stats["passed" if ok else "failed"] += 1
    for _, _, source, error in opened:
        if error is not None:
            stats = per_source.setdefault(source, {"passed": 0, "failed": 0})
            stats["failed"] += 1

    for _, writer, _ in active:
        writer.close()
    if active:
        await asyncio.gather(*(writer.wait_closed() for _, writer, _ in active), return_exceptions=True)
    return passed, len(errors), errors, per_source

async def main_async(args):
    started = time.perf_counter()
    print(f"Target: {args.host}:{args.port}")
    print(f"Server configured maximum active clients: {args.server_limit}")
    print(f"Rounds per test: {args.rounds}; stage timeout: {args.timeout:g}s")
    if args.source_ips:
        print(f"Source IPs (round-robin): {', '.join(args.source_ips)}")
    else:
        print("Source IPs: selected automatically by Windows")

    all_passed = True
    for connection_count in args.connection_cases:
        expected_success = min(connection_count, args.server_limit)
        expected_rejected = max(0, connection_count - args.server_limit)
        passed_total = 0
        failed_total = 0
        print(f"\nTesting {connection_count} simultaneous connections "
              f"(expected_successes: {expected_success}, over-limit: {expected_rejected})")

        for round_number in range(1, args.rounds + 1):
            passed, failed, errors, per_source = await run_round(
                args.host, args.port, connection_count, args.timeout, args.source_ips
            )
            passed_total += passed
            failed_total += failed

            if connection_count <= args.server_limit:
                round_ok = passed == connection_count and failed == 0
            else:
                # 上限档应全部成功; 超限档应达到容量上限, 且超出的请求应被拒绝。
                round_ok = passed == args.server_limit and failed >= expected_rejected
            all_passed = all_passed and round_ok

            status = "PASS" if round_ok else "FAIL"
            print(f"Round {round_number}/{args.rounds}: passed {passed}, failed/rejected {failed}; {status}")
            for source, stats in sorted(per_source.items()):
                print(f"  Source {source}: passed {stats['passed']}, failed {stats['failed']}")
            for error in errors[:3]:
                print(f"  Example error: {error}")

        print(f"  Test total: passed {passed_total}, failed/rejected {failed_total}")

    elapsed = time.perf_counter() - started
    print(f"\nOverall: {'PASS' if all_passed else 'FAIL'}; elapsed {elapsed:.2f}s")
    return 0 if all_passed else 1

def read_server_limit():
    """Read the compiled server's configured active-client limit from common.h."""
    common_header = Path(__file__).resolve().with_name("common.h")
    try:
        source = common_header.read_text(encoding="utf-8")
        match = re.search(r"MAX_CLIENTS\s*=\s*(\d+)\s*;", source)
        if match:
            return int(match.group(1))
    except OSError:
        pass
    return 128

def choose_connection_cases(args, parser):
    if args.boundary_test:
        return [args.server_limit, args.server_limit + args.overflow]
    if args.connections is not None:
        if args.connections < 1:
            parser.error("--connections must be at least 1")
        return [args.connections]

    print(f"Server configured maximum active clients: {args.server_limit}")
    prompt = ("Enter simultaneous connection count "
              f"(configured maximum: {args.server_limit}; larger values test beyond the limit): ")
    answer = input(prompt).strip()
    if not answer:
        return [args.server_limit]
    try:
        count = int(answer)
    except ValueError:
        parser.error("Enter a positive integer or 0")
    if count < 1:
        parser.error("Connection count must be at least 1")
    return [count]

def parse_args():
    parser = argparse.ArgumentParser(description="Concurrent stress test for the overlapped-I/O server")
    parser.add_argument("--host", default="192.168.50.1", help="Server IPv4 address (default: 192.168.50.1)")
    parser.add_argument("--port", type=int, default=1145, help="Server port (default: 1145)")
    parser.add_argument("--connections", type=int, default=None,
                        help="Simultaneous clients per round; omit to be prompted")
    parser.add_argument("--rounds", type=int, default=3, help="Number of repeated rounds (default: 3)")
    parser.add_argument("--timeout", type=float, default=15.0, help="Per-stage timeout in seconds (default: 15)")
    parser.add_argument("--server-limit", type=int, default=None,
                        help="Override the limit read from common.h")
    parser.add_argument("--boundary-test", action="store_true",
                        help="Run both the exact-limit and above-limit tests")
    parser.add_argument("--overflow", type=int, default=16,
                        help="Extra clients in the above-limit test (default: 16)")
    parser.add_argument("--source-ips", default="",
                        help="Comma-separated local IPv4 addresses, assigned round-robin; all must exist on this PC")
    args = parser.parse_args()

    if args.server_limit is None:
        args.server_limit = read_server_limit()
    if not (1 <= args.port <= 65535):
        parser.error("--port must be between 1 and 65535")
    if args.rounds < 1 or args.server_limit < 1 or args.timeout <= 0 or args.overflow < 1:
        parser.error("rounds, server limit, timeout, and overflow must be positive")
    if args.boundary_test and args.connections is not None:
        parser.error("--boundary-test cannot be combined with --connections")

    try:
        args.source_ips = [
            str(ipaddress.IPv4Address(value.strip()))
            for value in args.source_ips.split(",")
            if value.strip()
        ]
    except ipaddress.AddressValueError as exc:
        parser.error(f"--source-ips must contain valid IPv4 addresses: {exc}")

    args.connection_cases = choose_connection_cases(args, parser)
    return args

if __name__ == "__main__":
    if sys.platform != "win32":
        raise SystemExit("This test requires Windows asyncio Proactor/IOCP for overlapped socket I/O.")
    asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
    sys.exit(asyncio.run(main_async(parse_args())))

4.8 编译、运行和压力测试步骤

程序运行步骤如下:

  1. 确认服务器地址及客户端源地址已经配置在相应主机网卡上。
  2. 分别编译 server.exe 和 client.exe。
  3. 启动服务器程序,在监听 IPv4 和端口中输入 192.168.50.1 和 1145,点击“启动监听”。
  4. 启动客户端程序,设置服务器地址为 192.168.50.1、服务器端口为 1145;本地 IPv4 可填写 192.168.50.2,也可留空。
  5. 点击“连接并查询”,检查客户端日志是否显示请求已发送以及服务器返回的完整数列。
  6. 服务器维持监听状态时,在项目目录运行 python stress_test.py。

例如,以下命令尝试以两个源 IPv4 地址轮流建立160个同时连接:

python stress_test.py --host 192.168.50.1 --port 1145 --connections 160 --rounds 3 --source-ips 192.168.50.1,192.168.50.2

本次边界测试结果汇总于表6。测试在上限128时获得128个完整响应;测试144个连接时获得128个完整响应,另外16个连接被服务端拒绝,与代码中活动客户端上限一致。

表6 边界压力测试实测结果

测试档位 同时连接数 成功响应 失败或拒绝 判定
达到服务端上限 128 128 0 通过
超出服务端上限 144 128 16 通过, 超限连接被拒绝

两个源 IPv4 地址轮流绑定测试时,上限档中每个地址各完成 64 个连接,均成功;超限档中每个地址各有 64 个成功、8 个被拒绝。

图片8

图片9

图片10

图片11

4.9 结果分析

客户端接收的结果为:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

结果包括初始项 \(F_0=0\) 和 \(F_1=1\),递推项满足:

\[F_n = F_{n-1} + F_{n-2} \quad (4.9.1) \]

最后一项和下一项满足:

\[987 \le 1000 < 1597 \quad (4.9.2) \]

因此数列计算结果符合上限条件。本次并发验证也显示,服务器在 128 个活动连接时可以完成请求—响应;超过该容量的连接由服务端拒绝。


五、实验小结

5.1 实验问题及解决方法

表7 实验问题及处理措施

问题 原因 处理措施
客户端连接被拒绝 服务器目标地址填写为客户端地址,或服务器尚未监听 将目标地址改为服务器 192.168.50.1,端口使用 1145,并确认服务器日志显示监听成功
单次接收未包含完整消息 TCP 不保留应用层消息边界 使用四字节长度前缀,先收完整帧头,再按长度接收正文
单次发送未传完全部字节 Winsock 调用可能只传输部分数据 根据实际传输字节数推进偏移量,循环传输剩余数据
网络等待影响窗口响应 网络阻塞操作若放在窗口线程会阻塞消息循环 将监听、连接和数据收发放入工作线程,通过自定义窗口消息更新日志
多客户端连接数更新出现竞争 多个线程同时增加、减少客户端状态 使用临界区保护客户端套接字数组和连接计数
未区分容量上限和等待队列 listen() 队列长度与活动客户端数含义不同 使用 MAX_CLIENTS=128 限制活动客户端,并通过压力测试验证上限和超限表现
多源地址测试绑定失败 源 IPv4 未配置在运行压力脚本的电脑上 仅指定本机已有地址;跨主机测试时在各客户端主机分别运行脚本

5.2 重叠 I/O 模型工作过程分析

重叠 I/O 操作通过 WSAOVERLAPPED 结构关联操作状态和事件对象。应用程序调用 WSASend() 或 WSARecv() 提交操作后,操作可能立即完成,也可能返回 WSA_IO_PENDING。本程序随后通过 WSAGetOverlappedResult() 等待完成并取得真实传输字节数,按传输偏移判断是否还有剩余数据。

一次重叠收发的主要步骤为:
创建 OVERLAPPED 与事件对象 -> 提交 WSASend 或 WSARecv -> 检查操作状态 -> 等待完成并获取传输结果

相关实现集中在 common.h 的 TransferOverlapped();帧头和正文处理集中在 SendFrame()、ReceiveFrame()。服务器和客户端工作线程均调用这些函数执行连接建立后的数据收发。

本程序将网络操作放入工作线程,窗口线程通过消息循环处理界面事件。服务器的 accept() 和客户端的 connect() 在工作线程中执行,但它们并未使用重叠连接 API;本实验的重叠 I/O 主要应用于 WSASend() 和 WSARecv() 数据传输。

5.3 实验总结

本实验完成了客户端请求发送、服务器接收与校验、斐波那契数列计算、响应返回及客户端显示的完整流程。程序采用长度前缀协议处理 TCP 字节流边界,以 WSAOVERLAPPED、WSASend() 和 WSARecv() 实现连接后的重叠数据收发,并通过工作线程维持窗口响应能力。

服务器配置的活动客户端上限为 128。本次测试在 128 并发下获得 128 个成功响应,在 144 并发下获得 128 个成功响应并拒绝 16 个超限连接。压力脚本支持连接数输入、轮数和超时设置、多个本地源 IPv4 轮询以及上限/超限档测试。

5.4 小组分工

表8 小组成员及分工

成员 学号 分工
方致沅 20242136050 总体设计、公共协议、模块整合和联合调试
王鑫杰 20242136047 服务器窗口、监听和客户端连接管理、响应发送及资源释放
李润哲 20242136049 客户端窗口、连接参数、请求发送、响应接收和界面状态处理
康奕彬 20242136048 斐波那契算法、边界与并发测试、编译配置和实验记录整理

5.5 小组成员实验感想

5.5.1 方致沅实验感想

本次实验中,我主要负责系统总体设计、公共通信协议和模块整合。设计过程中需要统一客户端与服务器对地址、端口、数据帧和缓冲区上限的约定。调试初期出现连接拒绝,检查后发现服务器目标地址和客户端本地地址填写混淆;将服务器目标改为 192.168.50.1 后通信恢复。通过本次实验,我进一步理解了公共协议一致性对跨模块联调的重要作用,也掌握了长度前缀解决 TCP 消息边界问题的方法。

5.5.2 王鑫杰实验感想

本次实验中,我主要负责服务器窗口、监听线程和客户端连接管理。服务器需要同时处理多个客户端,因此必须为每个连接保存独立状态,并在请求结束后及时关闭套接字、释放连接槽位。压力测试达到 128 个活动客户端后,服务器会拒绝超出上限的连接。通过线程和临界区的配合,我更加熟悉了并发服务器中的连接生命周期及共享状态保护。

5.5.3 李润哲实验感想

本次实验中,我主要负责客户端窗口、网络参数输入和请求—响应过程。客户端需要区分服务器目标地址与本地绑定地址;若把两者填反,即使服务器程序正确运行也会导致连接失败。数据收发中还要考虑请求可能被分段传输,因此客户端必须按长度字段完整接收响应。通过本次实验,我掌握了客户端参数校验、重叠收发调用和界面状态恢复等处理方法。

5.5.4 康奕彬实验感想

本次实验中,我主要负责斐波那契算法核对、压力测试和结果整理。算法需要从 0 和 1 开始递推,并包含所有不超过 1000 的项;因此在 987 后计算得到 1597 时必须停止。压力测试不仅要观察正常请求是否成功,还需要设置连接数达到上限和超过上限的情况。本次测试在 128 并发下全部成功,在 144 并发下出现预期的 16 个超限拒绝,使我认识到测试结果应同时说明成功数、失败数和系统容量配置。


六、附录

《Windows 网络与通信程序设计》陈香凝,王烨阳,陈婷婷,张睁,人民邮电出版社,2017.3 第 3 版。

posted @ 2026-11-12 22:55  fangzhiyuan  阅读(13)  评论(0)    收藏  举报