Windows同步技术-等待多个对象(二)

等待多个MAXIMUM_WAIT_OBJECTS组

创建一个线程来等待 MAXIMUM_WAIT_OBJECTS 句柄，然后等待该线程和其他句柄。 使用此技术可将句柄分解为 MAXIMUM_WAIT_OBJECTS组。这个方案的大概代码如下：

#include <windows.h>
#include <vector>
#include <algorithm>

#define MAXIMUM_WAIT_OBJECTS 64

// 线程参数结构
struct ThreadParams {
    HANDLE handles[MAXIMUM_WAIT_OBJECTS];
    DWORD count;
    DWORD globalStartIndex; // 全局句柄数组的起始索引
};

// 辅助线程函数
DWORD WINAPI WaitGroupThread(LPVOID lpParam) {
    ThreadParams* params = static_cast<ThreadParams*>(lpParam);
    DWORD result = WaitForMultipleObjects(
        params->count,
        params->handles,
        FALSE,  // 任意对象触发即返回
        INFINITE
    );

    DWORD exitCode = (DWORD)-1;
    if (result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + params->count) {
        exitCode = result - WAIT_OBJECT_0; // 计算组内触发索引
    }

    delete params; // 释放动态分配的内存
    return exitCode;
}

int main() {
    // 示例：创建多个事件句柄（假设数量超过 MAXIMUM_WAIT_OBJECTS）
    const DWORD NUM_HANDLES = 100;
    std::vector<HANDLE> handles(NUM_HANDLES);
    for (DWORD i = 0; i < NUM_HANDLES; ++i) {
        handles[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
    }

    // 分组处理
    DWORD numGroups = (NUM_HANDLES + MAXIMUM_WAIT_OBJECTS - 1) / MAXIMUM_WAIT_OBJECTS;
    std::vector<HANDLE> threadHandles(numGroups);

    for (DWORD i = 0; i < numGroups; ++i) {
        // 动态分配线程参数
        ThreadParams* params = new ThreadParams;
        params->globalStartIndex = i * MAXIMUM_WAIT_OBJECTS;
        params->count = std::min(MAXIMUM_WAIT_OBJECTS, NUM_HANDLES - params->globalStartIndex);

        // 复制当前组的句柄
        for (DWORD j = 0; j < params->count; ++j) {
            params->handles[j] = handles[params->globalStartIndex + j];
        }

        // 创建线程
        threadHandles[i] = CreateThread(
            NULL,
            0,
            WaitGroupThread,
            params,
            0,
            NULL
        );

        if (!threadHandles[i]) {
            delete params; // 创建线程失败时释放内存
        }
    }

    // 主线程等待辅助线程和其他句柄（这里以等待所有辅助线程为例）
    while (true) {
        DWORD result = WaitForMultipleObjects(
            numGroups,
            threadHandles.data(),
            FALSE,  // 任意线程完成即返回
            INFINITE
        );

        if (result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + numGroups) {
            DWORD threadIndex = result - WAIT_OBJECT_0;
            HANDLE hThread = threadHandles[threadIndex];

            // 获取线程退出码
            DWORD exitCode;
            if (GetExitCodeThread(hThread, &exitCode) && exitCode != (DWORD)-1) {
                // 计算全局索引并处理
                DWORD globalIndex = threadIndex * MAXIMUM_WAIT_OBJECTS + exitCode;
                printf("Handle %d triggered\n", globalIndex);

                // 重新创建线程以继续等待（此处根据需求调整）
                CloseHandle(hThread);
                ThreadParams* params = new ThreadParams;
                params->globalStartIndex = threadIndex * MAXIMUM_WAIT_OBJECTS;
                params->count = std::min(MAXIMUM_WAIT_OBJECTS, NUM_HANDLES - params->globalStartIndex);
                for (DWORD j = 0; j < params->count; ++j) {
                    params->handles[j] = handles[params->globalStartIndex + j];
                }
                threadHandles[threadIndex] = CreateThread(NULL, 0, WaitGroupThread, params, 0, NULL);
            }
        }
    }

    // 清理资源（此处为示例，实际需根据循环退出条件处理）
    for (auto& h : handles) {
        CloseHandle(h);
    }
    for (auto& h : threadHandles) {
        CloseHandle(h);
    }

    return 0;
}