【现代C++】线程支持库

现代C++（C++11及其之后的版本）引入了标准的线程支持库，使得多线程编程变得更加简单和可移植。这个库提供了线程管理、互斥量、条件变量和其他同步原语。

1. std::thread - 基本线程

std::thread允许创建执行特定任务的线程。

#include <iostream>
#include <thread>

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

void basicThread() {
    std::thread t(helloFunction);
    t.join();  // 等待线程完成
}

2. 传递参数给线程函数

线程函数可以接受参数，和普通函数一样。

#include <iostream>
#include <thread>

void printMessage(const std::string& message) {
    std::cout << message << std::endl;
}

void threadWithArguments() {
    std::thread t(printMessage, "Hello from thread with argument!");
    t.join();
}

3. std::mutex - 互斥量

互斥量用于同步对共享资源的访问。

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

std::mutex mtx;

void printBlocked(const std::string& message) {
    mtx.lock();
    std::cout << message << std::endl;
    mtx.unlock();
}

void mutexExample() {
    std::thread t1(printBlocked, "Thread 1");
    std::thread t2(printBlocked, "Thread 2");

    t1.join();
    t2.join();
}

4. std::lock_guard - 自动管理互斥量

std::lock_guard提供了一种便捷的RAII风格的方式来自动上锁和解锁互斥量。

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

std::mutex mtx;

void safePrint(const std::string& message) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << message << std::endl;
    // 互斥量在lock_guard对象被销毁时自动解锁
}

void lockGuardExample() {
    std::thread t1(safePrint, "Thread 1 with lock_guard");
    std::thread t2(safePrint, "Thread 2 with lock_guard");

    t1.join();
    t2.join();
}

5. std::async和std::future - 异步执行

std::async允许异步执行函数，并通过std::future获取结果。

#include <iostream>
#include <future>

int compute() {
    return 42;  // 模拟计算
}

void asyncExample() {
    std::future<int> result = std::async(compute);
    std::cout << "The answer is " << result.get() << std::endl;
}

6. std::condition_variable - 条件变量

条件变量用于线程间的同步，允许线程在特定条件下等待或通知其他线程。

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

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

void printId(int id) {
    std::unique_lock<std::mutex> lock(mtx);
    while (!ready) cv.wait(lock);
    std::cout << "Thread " << id << std::endl;
}

void go() {
    std::unique_lock<std::mutex> lock(mtx);
    ready = true;
    cv.notify_all();
}

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

    std::cout << "10 threads ready to race..." << std::endl;
    go();

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