求助：基于WINAPI与RAII的4线程C++程序随机终止问题排查

问题根源 #

你的RAII版本程序中线程随机中途停止，核心原因是线程句柄被提前关闭：

• 在main的循环里，ThreadHandle hThread是局部对象，每次循环迭代结束后，该对象会被销毁，触发析构函数调用CloseHandle关闭线程句柄。
• 你存入std::vector<HANDLE>的是句柄的副本，但此时原句柄已经被关闭，WaitForMultipleObjects使用这些无效句柄会触发未定义行为——最常见的结果是等待提前结束，main函数退出后进程终止，未执行完的线程被强制终止。

修复方案 #

要实现正确的RAII管理，需要保证线程句柄的生命周期覆盖整个等待过程，同时避免多个RAII对象管理同一个句柄的风险。以下是修正后的完整代码：

ThreadHandle.h #

#pragma once
#include <windows.h>
#include <stdexcept>

class ThreadHandle
{
public:
    ThreadHandle() = default;
    explicit ThreadHandle(LPTHREAD_START_ROUTINE function, LPVOID lpParameter);
    
    // 禁用拷贝语义：避免多个对象管理同一个线程句柄
    ThreadHandle(const ThreadHandle&) = delete;
    ThreadHandle& operator=(const ThreadHandle&) = delete;
    
    // 启用移动语义：支持安全转移句柄所有权
    ThreadHandle(ThreadHandle&& other) noexcept;
    ThreadHandle& operator=(ThreadHandle&& other) noexcept;
    
    ~ThreadHandle();
    
    // 提供到HANDLE的转换，方便WinAPI调用
    operator HANDLE() const { return hThread; }

private:
    HANDLE hThread = nullptr;
};

ThreadHandle.cpp #

#include "ThreadHandle.h"

ThreadHandle::ThreadHandle(LPTHREAD_START_ROUTINE function, LPVOID lpParameter)
{
    hThread = CreateThread(
        nullptr,
        0,
        function,
        lpParameter,
        0,
        nullptr
    );
    if (hThread == nullptr)
    {
        throw std::runtime_error("Failed to create thread");
    }
}

ThreadHandle::ThreadHandle(ThreadHandle&& other) noexcept
    : hThread(other.hThread)
{
    other.hThread = nullptr; // 转移所有权后清空原对象的句柄
}

ThreadHandle& ThreadHandle::operator=(ThreadHandle&& other) noexcept
{
    if (this != &other)
    {
        // 先关闭当前对象的句柄（如果存在）
        if (hThread != nullptr)
        {
            CloseHandle(hThread);
        }
        hThread = other.hThread;
        other.hThread = nullptr;
    }
    return *this;
}

ThreadHandle::~ThreadHandle()
{
    if (hThread != nullptr)
    {
        CloseHandle(hThread);
    }
}

main.cpp #

#include <vector>
#include <iostream>
#include "ThreadHandle.h"

constexpr int THREAD_COUNT = 4;
constexpr int LOOP_COUNT = 1000;

DWORD WINAPI LoopThousand(LPVOID lpParam)
{
    int threadId = reinterpret_cast<int>(lpParam);
    for (int i = 0; i < LOOP_COUNT; ++i)
    {
        // 注意：std::cout不是线程安全的，多线程同时输出会导致内容混乱
        // 如果需要有序输出，可添加临界区等同步机制
        std::cout << "Thread " << threadId << ", var = " << i << std::endl;
    }
    return 0;
}

int main()
{
    std::vector<ThreadHandle> threadHandles;
    try
    {
        // 创建线程并将RAII对象存入vector，保证句柄生命周期覆盖等待过程
        for (int i = 1; i <= THREAD_COUNT; ++i)
        {
            threadHandles.emplace_back(LoopThousand, reinterpret_cast<LPVOID>(i));
        }

        // 提取有效句柄用于等待
        std::vector<HANDLE> handles;
        handles.reserve(THREAD_COUNT);
        for (const auto& th : threadHandles)
        {
            handles.push_back(static_cast<HANDLE>(th));
        }

        DWORD dwWaitResult = WaitForMultipleObjects(
            THREAD_COUNT,
            handles.data(),
            TRUE,
            INFINITE
        );

        if (dwWaitResult == WAIT_FAILED)
        {
            throw std::runtime_error("WaitForMultipleObjects failed");
        }
    }
    catch (const std::exception& e)
    {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }

    // vector中的ThreadHandle对象会在main结束时自动销毁，调用CloseHandle关闭句柄
    return 0;
}

关键修复说明 #

1. RAII类语义修正：
   • 禁用拷贝构造和赋值，避免多个ThreadHandle对象管理同一个线程句柄，防止重复关闭或提前关闭。
   • 添加移动构造和赋值，支持将句柄所有权安全转移到vector中，保证RAII对象的生命周期可控。
2. 句柄生命周期管理：
   • 将ThreadHandle对象存储在vector中，确保对象生命周期覆盖WaitForMultipleObjects的整个过程，句柄不会被提前关闭。
3. 额外提示：
   • std::cout是线程不安全的，多线程同时输出会导致内容混乱。如果需要有序输出，可以使用CRITICAL_SECTION等同步机制保护输出操作。

内容的提问来源于stack exchange，提问作者Torch