求线程模块

炫选炫

求助一个这样的线程模块，求大佬指点

炫选炫

AI回答

#ifndef THREAD_MODULE_H
#define THREAD_MODULE_H

#include <windows.h>
#include <thread>
#include <functional>
#include <unordered_map>
#include <mutex>
#include <atomic>

class ThreadModule {
private:
    struct ThreadInfo {
        HANDLE handle;
        std::thread::id stdThreadId;
        std::atomic<bool> isRunning;
        std::atomic<bool> shouldStop;
        
        ThreadInfo() : handle(NULL), isRunning(false), shouldStop(false) {}
    };
   
    static std::unordered_map<DWORD, ThreadInfo> threads;
    static std::mutex threadMapMutex;
   
    template<typename Func, typename... Args>
    static DWORD WINAPI ThreadWrapper(LPVOID param) {
        auto* funcWrapper = static_cast<std::function<void()>*>(param);
        DWORD threadId = GetCurrentThreadId();
        
        {
            std::lock_guard<std::mutex> lock(threadMapMutex);
            if (threads.find(threadId) != threads.end()) {
                threads[threadId].isRunning = true;
            }
        }
        
        (*funcWrapper)();
        
        {
            std::lock_guard<std::mutex> lock(threadMapMutex);
            if (threads.find(threadId) != threads.end()) {
                threads[threadId].isRunning = false;
            }
        }
        
        delete funcWrapper;
        return 0;
    }
   
public:
    // 线程开启
    template<typename Func, typename... Args>
    static DWORD 线程开启(Func&& func, Args&&... args) {
        auto* funcWrapper = new std::function<void()>(
            std::bind(std::forward<Func>(func), std::forward<Args>(args)...)
        );
        
        DWORD threadId;
        HANDLE hThread = CreateThread(
            NULL,                   // 默认安全属性
            0,                      // 默认堆栈大小
            ThreadWrapper<Func, Args...>,  // 线程函数
            funcWrapper,            // 线程参数
            0,                      // 立即运行
            &threadId              // 接收线程ID
        );
        
        if (hThread != NULL) {
            std::lock_guard<std::mutex> lock(threadMapMutex);
            ThreadInfo info;
            info.handle = hThread;
            info.stdThreadId = std::this_thread::get_id();
            info.isRunning = true;
            info.shouldStop = false;
            threads[threadId] = info;
            return threadId;
        }
        
        delete funcWrapper;
        return 0;
    }
   
    // 线程关闭
    static bool 线程关闭(DWORD 句柄, int 类型 = 0) {
        std::lock_guard<std::mutex> lock(threadMapMutex);
        auto it = threads.find(句柄);
        if (it == threads.end()) {
            return false;
        }
        
        HANDLE hThread = it->second.handle;
        bool result = false;
        
        if (类型 == 0) {
            // 安全关闭
            it->second.shouldStop = true;
            // 等待线程自然结束（最多等待5秒）
            DWORD waitResult = WaitForSingleObject(hThread, 5000);
            if (waitResult == WAIT_OBJECT_0) {
                result = true;
            } else {
                // 如果线程没有响应，可能需要强制终止
                result = (TerminateThread(hThread, 0) != 0);
            }
        } else if (类型 == 1) {
            // 强制关闭
            result = (TerminateThread(hThread, 0) != 0);
        }
        
        if (result) {
            CloseHandle(hThread);
            threads.erase(it);
        }
        
        return result;
    }
   
    // 线程等待
    static int 线程等待(DWORD 句柄, int 等待时间) {
        std::lock_guard<std::mutex> lock(threadMapMutex);
        auto it = threads.find(句柄);
        if (it == threads.end()) {
            return -2; // 等待失败
        }
        
        HANDLE hThread = it->second.handle;
        threadMapMutex.unlock(); // 释放锁以避免死锁
        
        DWORD timeout = (等待时间 <= -1) ? INFINITE : static_cast<DWORD>(等待时间);
        DWORD result = WaitForSingleObject(hThread, timeout);
        
        switch (result) {
            case WAIT_OBJECT_0:
                return 0;  // 核心对象已被激活
            case WAIT_TIMEOUT:
                return -1; // 等待超时
            case WAIT_ABANDONED:
                return -3; // 线程在结束时没有释放核心对象
            default:
                return -2; // 等待失败
        }
    }
   
    // 线程暂停
    static bool 线程暂停(DWORD 句柄) {
        std::lock_guard<std::mutex> lock(threadMapMutex);
        auto it = threads.find(句柄);
        if (it == threads.end()) {
            return false;
        }
        
        HANDLE hThread = it->second.handle;
        return (SuspendThread(hThread) != (DWORD)-1);
    }
   
    // 线程恢复
    static bool 线程恢复(DWORD 句柄) {
        std::lock_guard<std::mutex> lock(threadMapMutex);
        auto it = threads.find(句柄);
        if (it == threads.end()) {
            return false;
        }
        
        HANDLE hThread = it->second.handle;
        return (ResumeThread(hThread) != (DWORD)-1);
    }
   
    // 线程获取id
    static DWORD 线程获取id() {
        return GetCurrentThreadId();
    }
   
    // 线程获取状态
    static bool 线程获取状态(DWORD 句柄) {
        std::lock_guard<std::mutex> lock(threadMapMutex);
        auto it = threads.find(句柄);
        if (it == threads.end()) {
            return false;
        }
        
        // 检查线程是否仍在运行
        DWORD exitCode;
        if (GetExitCodeThread(it->second.handle, &exitCode)) {
            return (exitCode == STILL_ACTIVE) && it->second.isRunning;
        }
        
        return false;
    }
   
    // 清理资源（可选）
    static void 清理() {
        std::lock_guard<std::mutex> lock(threadMapMutex);
        for (auto& pair : threads) {
            CloseHandle(pair.second.handle);
        }
        threads.clear();
    }
};

// 静态成员定义
std::unordered_map<DWORD, ThreadModule::ThreadInfo> ThreadModule::threads;
std::mutex ThreadModule::threadMapMutex;

#endif // THREAD_MODULE_H

炫选炫

AI使用示例：

#include <iostream>
#include <chrono>
#include "ThreadModule.h"

// 测试函数
void testFunction(int id, const std::string& message) {
    for (int i = 0; i < 5; ++i) {
        std::cout << "Thread " << id << ": " << message << " - " << i << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}

int main() {
    // 开启线程
    DWORD threadId1 = ThreadModule::线程开启(testFunction, 1, "Hello");
    DWORD threadId2 = ThreadModule::线程开启(testFunction, 2, "World");
   
    std::cout << "Thread 1 ID: " << threadId1 << std::endl;
    std::cout << "Thread 2 ID: " << threadId2 << std::endl;
    std::cout << "Main thread ID: " << ThreadModule::线程获取id() << std::endl;
   
    // 检查线程状态
    std::cout << "Thread 1 running: " << ThreadModule::线程获取状态(threadId1) << std::endl;
   
    // 暂停线程1
    std::this_thread::sleep_for(std::chrono::seconds(2));
    ThreadModule::线程暂停(threadId1);
    std::cout << "Thread 1 paused" << std::endl;
   
    // 恢复线程1
    std::this_thread::sleep_for(std::chrono::seconds(2));
    ThreadModule::线程恢复(threadId1);
    std::cout << "Thread 1 resumed" << std::endl;
   
    // 等待线程2完成
    int waitResult = ThreadModule::线程等待(threadId2, -1);
    std::cout << "Wait result for thread 2: " << waitResult << std::endl;
   
    // 关闭线程1
    bool closeResult = ThreadModule::线程关闭(threadId1, 0);
    std::cout << "Thread 1 close result: " << closeResult << std::endl;
   
    // 清理资源
    ThreadModule::清理();
   
    return 0;
}


这个实现提供了以下特性：

线程开启：支持任意函数和参数，使用模板和完美转发
线程关闭：支持安全关闭（等待线程结束）和强制关闭
线程等待：支持有限时间等待和无限等待
线程暂停/恢复：使用Windows API的SuspendThread和ResumeThread
线程获取id：返回当前线程ID
线程获取状态：检查线程是否正在运行
注意事项：

这个实现是Windows平台特定的，使用了Windows API
线程暂停/恢复功能应谨慎使用，可能导致死锁
强制关闭线程（类型=1）可能导致资源泄漏和程序不稳定
建议在程序结束前调用清理函数释放所有资源

lczsqzh

软件案例里面有