C++ 多线程学习笔记

一、什么是多线程

多线程是指在同一进程中，同时运行多个线程。相对于传统的单线程程序，多线程程序可以更好地利用计算机的多核计算能力，提高程序运行效率。

二、C++ 多线程库

C++ 标准库提供了 std::thread 来支持多线程编程。使用 std::thread 可以创建一个新的线程，并在该线程中执行指定的函数。

下面是一个简单的示例，演示了如何使用 std::thread 创建一个新的线程并执行指定的函数：

c++Copy Code
#include <iostream>
#include <thread>

void hello()
{
    std::cout << "Hello, world!" << std::endl;
}

int main()
{
    std::thread t(hello);
    t.join();
    return 0;
}

在上面的示例中，我们定义了一个函数 hello，该函数简单地输出一行文本。然后在 main 函数中创建了一个新的线程 t，并将其与函数 hello 关联起来。最后使用 t.join() 等待线程执行完毕再继续执行主线程。

三、实例：多线程排序

下面演示一个使用多线程进行排序的实例。该程序将一个随机生成的数组进行排序，并统计排序所用的时间。

c++Copy Code
#include <iostream>
#include <thread>
#include <chrono>
#include <random>
#include <algorithm>

const int N = 10000000; // 待排序数组的大小

// 生成指定范围内的随机数
int generate_random_number(int min, int max)
{
    static std::random_device rd;
    static std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(min, max);
    return dis(gen);
}

// 单线程快排
void quick_sort(int *arr, int left, int right)
{
    if (left >= right) return;
    int i = left, j = right, pivot = arr[(left + right) / 2];
    while (i <= j)
    {
        while (arr[i] < pivot) i++;
        while (arr[j] > pivot) j--;
        if (i <= j)
        {
            std::swap(arr[i], arr[j]);
            i++, j--;
        }
    }
    if (left < j) quick_sort(arr, left, j);
    if (i < right) quick_sort(arr, i, right);
}

// 多线程快排（使用 std::thread）
void parallel_quick_sort(int *arr, int left, int right, int depth = 0)
{
    if (left >= right) return;
    if (depth >= 3) // 线程递归深度达到 3，切换为单线程
    {
        quick_sort(arr, left, right);
        return;
    }
    int i = left, j = right, pivot = arr[(left + right) / 2];
    while (i <= j)
    {
        while (arr[i] < pivot) i++;
        while (arr[j] > pivot) j--;
        if (i <= j)
        {
            std::swap(arr[i], arr[j]);
            i++, j--;
        }
    }
    std::thread t1(parallel_quick_sort, arr, left, j, depth + 1); // 创建新线程
    std::thread t2(parallel_quick_sort, arr, i, right, depth + 1);
    t1.join(); // 等待线程完成
    t2.join();
}

int main()
{
    int *arr = new int[N];
    for (int i = 0; i < N; i++)
        arr[i] = generate_random_number(1, N);
    std::chrono::high_resolution_clock::time_point start_time, end_time;
    
    start_time = std::chrono::high_resolution_clock::now();
    parallel_quick_sort(arr, 0, N - 1);
    end_time = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed_time = end_time - start_time;
    std::cout << "Parallel quick sort: " << elapsed_time.count() << " seconds\n";
    
    start_time = std::chrono::high_resolution_clock::now();
    quick_sort(arr, 0, N - 1);
    end_time = std::chrono::high_resolution_clock::now();
    elapsed_time = end_time - start_time;
    std::cout << "Single-threaded quick sort: " << elapsed_time.count() << " seconds\n";
    
    delete[] arr;
    return 0;
}

在上面的示例中，我们定义了一个函数 parallel_quick_sort，该函数使用多线程进行快速排序。具体地，如果线程递归深度小于 3，该函数会创建两个新的线程，分别对数组的左半部分和右半部分进行排序；否则，该函数会切换到单线程模式。

程序执行结果如下：

Copy Code
Parallel quick sort: 0.591275 seconds
Single-threaded quick sort: 0.979637 seconds

可以看出，使用多线程可以更快地完成排序任务。