深入理解 C++11 多线程编程：从入门到实践

C++ 多线程编程是指使用 C++ 提供的多线程库来并行执行代码块，从而提高程序的性能和响应能力。C++11 标准引入了多线程支持，使得在 C++ 中进行多线程编程变得更加容易和直观。以下是 C++ 多线程编程的基本知识，并附有例子代码。

多线程的基本概念

1. 线程（Thread）：线程是进程中的一个执行单元，每个线程有自己的堆栈，但与其他线程共享程序的全局内存。
2. 竞争条件（Race Condition）：多个线程并发访问同一内存区域并试图同时修改它，可能导致未定义行为。
3. 互斥锁（Mutex）：互斥锁用来确保某段代码在同一时间只被一个线程执行。
4. 条件变量（Condition Variable）：对于某些需要线程同步的情况，可使用条件变量。

C++11 中的多线程编程

C++11 提供了一些新的类和函数来支持多线程编程：

• std::thread：用于创建和管理线程。
• std::mutex：用于互斥锁，以防止多线程同时访问共享资源。
• std::lock_guard 和 std::unique_lock：用于管理互斥锁。
• std::condition_variable：用于线程间的条件同步。

示例代码

下面的示例代码展示了如何在 C++ 中使用 std::thread 创建线程，使用 std::mutex 来保证对共享资源的互斥访问，并使用 std::condition_variable 进行线程同步。

示例 1：基本线程创建和管理

#include <iostream>
#include <thread>

void print_hello() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(print_hello); // 创建一个新线程
    t.join(); // 等待线程完成
    return 0;
}

示例 2：互斥锁保护共享数据

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>

std::mutex mtx; // 互斥锁保护共享数据
int counter = 0;

void increment() {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 获取互斥锁
        ++counter;
    }
}

int main() {
    std::vector<std::thread> threads;

    // 创建多个线程
    for (int i = 0; i < 10; ++i) {
        threads.push_back(std::thread(increment));
    }

    // 等待所有线程执行完毕
    for (auto& t : threads) {
        t.join();
    }

    std::cout << "Counter: " << counter << std::endl; // 输出计数器值
    return 0;
}

示例 3：条件变量同步线程

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void print_id(int id) {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; }); // 等待 ready 为 true
    // 任何线程执行到这里，ready 不再为 false
    std::cout << "Thread " << id << std::endl;
}

void set_ready() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_all(); // 通知所有等待的线程
}

int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i) {
        threads[i] = std::thread(print_id, i);
    }

    std::thread t(set_ready);

    for (auto& thr : threads) {
        thr.join();
    }
    t.join();
    return 0;
}

解释

1. 创建线程：std::thread 类用于创建线程。线程的入口函数可以是函数、lambda 表达式、成员函数等。
2. 互斥锁：std::mutex 和 std::lock_guard 用于线程安全的访问共享资源。std::lock_guard 也可以使用 std::unique_lock 替代，它提供更多的控制。
3. 条件变量：std::condition_variable 用于线程间的等待和通知机制。结合 std::unique_lock 使用，用 notify_one 或 notify_all 唤醒等待的线程。

小结

多线程编程可以显著提高程序的执行效率，尤其是在 I/O 密集型任务或多核环境下。通过 C++11 提供的多线程支持，可以更加方便地进行线程的创建、管理和同步。在实际编程中，要特别注意线程安全和死锁等潜在问题。