C++：基于CreateThread 实现多线程（附带源码）

基于CreateThread实现C++多线程

项目背景与实现思路

多线程编程在现代软件开发中尤为重要，尤其是在需要并行处理任务时。C++ 提供了多种方式来创建多线程，CreateThread 是 Windows API 提供的一种线程创建方式。与 C++11 标准中的 std::thread 比较，CreateThread 更为底层，提供了更多的控制权，但是同时也需要开发者手动管理线程的生命周期。

在本项目中，我们将通过 CreateThread 函数实现多线程，并演示如何在线程中执行任务、管理线程以及处理多线程的同步问题。通过本项目，读者可以了解如何使用 Windows API 进行多线程开发，掌握线程创建、同步和结束的基本方法。

项目目标

1. 使用 CreateThread 创建多线程。
2. 在线程中执行不同的任务，展示线程的基本操作。
3. 处理线程的同步问题，确保线程间的安全性。
4. 了解线程的生命周期管理，以及线程结束的回收机制。

项目实现步骤

1. 引入必要的头文件

   由于我们使用的是 Windows API 中的 CreateThread 函数，所以需要引入 <windows.h> 头文件。

2. 创建线程函数

   每个线程需要执行的任务是通过一个线程函数来实现的。线程函数的原型为：

DWORD WINAPI ThreadFunction(LPVOID lpParam);

• 其中 lpParam 是一个指向任意类型数据的指针，可以通过它传递参数。

• 创建线程

  使用 CreateThread 函数来创建线程，CreateThread 的原型如下：

HANDLE CreateThread(
  LPSECURITY_ATTRIBUTES   lpThreadAttributes,
  SIZE_T                  dwStackSize,
  LPTHREAD_START_ROUTINE  lpStartAddress,
  LPVOID                  lpParameter,
  DWORD                   dwCreationFlags,
  LPDWORD                 lpThreadId
);

1. • lpStartAddress 是线程函数的入口地址。
   • lpParameter 是传递给线程的参数。
   • dwCreationFlags 可以设为 0 表示立即创建线程。

2. 管理线程

   在主线程中，可以通过 WaitForSingleObject 等函数等待线程的执行结果，确保主线程在所有子线程执行完后再结束。

3. 处理线程同步

   对于多个线程共享资源的情况，必须使用同步机制（如互斥量）来保证线程的安全性。Windows 提供了 CreateMutex 和 WaitForSingleObject 等函数来管理资源访问。

4. 清理与结束线程

   在所有线程完成任务后，需要清理资源，调用 CloseHandle 关闭线程句柄。

完整代码

#include <windows.h>
#include <iostream>
#include <vector>
#include <mutex>

// 线程任务函数
DWORD WINAPI ThreadFunction(LPVOID lpParam)
{
    // 输出线程编号，模拟任务执行
    int threadNum = *((int*)lpParam);
    std::cout << "Thread " << threadNum << " is starting." << std::endl;

    // 模拟任务执行
    Sleep(1000);  // 睡眠 1 秒钟，模拟耗时操作

    std::cout << "Thread " << threadNum << " has finished." << std::endl;
    return 0;
}

int main()
{
    const int numThreads = 5; // 创建 5 个线程
    HANDLE hThreads[numThreads];  // 存储线程句柄
    DWORD threadId[numThreads];   // 存储线程ID
    int threadParams[numThreads]; // 存储线程的参数

    // 创建多个线程
    for (int i = 0; i < numThreads; ++i)
    {
        threadParams[i] = i + 1;  // 设置线程的编号作为参数
        hThreads[i] = CreateThread(
            NULL,                  // 默认安全属性
            0,                     // 默认堆栈大小
            ThreadFunction,        // 线程执行的函数
            &threadParams[i],      // 传递给线程的参数
            0,                     // 默认创建标志
            &threadId[i]           // 线程ID
        );
        if (hThreads[i] == NULL)
        {
            std::cerr << "Thread creation failed!" << std::endl;
            return 1;
        }
    }

    // 等待所有线程完成
    WaitForMultipleObjects(numThreads, hThreads, TRUE, INFINITE);

    // 关闭线程句柄
    for (int i = 0; i < numThreads; ++i)
    {
        CloseHandle(hThreads[i]);
    }

    std::cout << "All threads have finished." << std::endl;

    return 0;
}

代码解读

1. 线程函数：

   线程函数 ThreadFunction 接收一个 LPVOID 类型的参数，这个参数在此案例中是一个指向整数的指针。每个线程根据其编号输出信息，模拟任务执行并休眠 1 秒钟，然后输出结束信息。

2. 线程创建：

   在 main 函数中，我们创建了 5 个线程。每个线程通过 CreateThread 被启动，并传入一个线程编号。CreateThread 的返回值是一个 HANDLE 类型的线程句柄，用于后续的管理。

3. 等待线程完成：

   使用 WaitForMultipleObjects 函数来等待所有线程的完成。此函数会阻塞直到所有线程结束。

4. 清理资源：

   当所有线程完成后，我们通过 CloseHandle 关闭每个线程的句柄，确保资源被释放。

线程同步

在这个示例中，线程之间并没有共享资源，因此不需要显式的同步机制。然而，在多线程编程中，线程之间常常需要共享数据，必须使用互斥量（mutex）或者临界区（critical section）来确保数据的线程安全。

以下是如何使用互斥量的示例代码：

std::mutex mtx;  // 全局互斥量

DWORD WINAPI ThreadFunction(LPVOID lpParam)
{
    int threadNum = *((int*)lpParam);
    
    // 线程执行前先锁定互斥量
    mtx.lock();
    std::cout << "Thread " << threadNum << " is starting." << std::endl;
    mtx.unlock();  // 释放互斥量

    Sleep(1000);

    mtx.lock();
    std::cout << "Thread " << threadNum << " has finished." << std::endl;
    mtx.unlock();

    return 0;
}

在此示例中，我们使用了 std::mutex 来保护对输出的访问，防止多个线程同时打印信息时出现混乱。

项目总结

通过本项目，我们成功实现了基于 CreateThread 函数的多线程程序。这个简单的示例展示了如何创建线程、在线程中执行任务、等待线程结束以及管理线程的生命周期。虽然 CreateThread 提供了更为底层的控制，但它的使用相比于 C++11 标准中的 std::thread 更加繁琐，需要开发者手动管理线程的句柄、ID 等。

在实际项目中，使用 CreateThread 可以获得更细粒度的线程控制，但在较为复杂的项目中，建议使用更高级的 C++ 标准库 std::thread，因为它提供了更简洁且易于管理的线程处理方式。

对于多线程编程，线程同步是一个非常重要的问题。开发者必须小心处理线程之间的资源竞争问题，合理使用锁机制来避免死锁和数据不一致的问题。