C++线程同步的几种方式

// C++ std::mutex 实现互斥
#include <iostream>
#include <thread>
#include <mutex>

class Counter {
private:
    int count = 0;
    std::mutex mtx;
public:
    void increment() {
        std::lock_guard<std::mutex> lock(mtx);
        count++;
    }
    int getCount() const { return count; }
};

// C++ 信号量示例 (C++20 引入 std::counting_semaphore)
#include <iostream>
#include <thread>
#include <semaphore>

std::counting_semaphore<10> semaphore(3); // 允许3个线程同时访问

void accessResource() {
    semaphore.acquire();
    try {
        // 访问共享资源
        std::cout << "Thread accessing resource" << std::endl;
    } catch (...) {
        semaphore.release();
        throw;
    }
    semaphore.release();
}

// C++ 使用 std::mutex 和 std::condition_variable
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

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

void workerThread() {
    std::unique_lock<std::mutex> lock(mtx);
    while (!conditionMet) {
        cv.wait(lock); // 释放锁并等待
    }
    // 条件满足，执行操作
    std::cout << "Condition met, proceeding..." << std::endl;
}

// C++ std::shared_mutex 示例 (C++17)
#include <iostream>
#include <thread>
#include <shared_mutex>

std::shared_mutex rwLock;
int sharedData = 0;

void reader() {
    std::shared_lock<std::shared_mutex> lock(rwLock);
    // 读取数据
    std::cout << "Reading data: " << sharedData << std::endl;
}

void writer() {
    std::unique_lock<std::shared_mutex> lock(rwLock);
    // 修改数据
    sharedData++;
    std::cout << "Writing data: " << sharedData << std::endl;
}

// C++ std::latch 示例 (C++20)
#include <iostream>
#include <thread>
#include <latch>

std::latch latch(3); // 需要3个线程完成

void worker() {
    // 执行任务
    std::cout << "Worker thread completing task" << std::endl;
    latch.count_down(); // 计数器减1
}

int main() {
    std::thread t1(worker);
    std::thread t2(worker);
    std::thread t3(worker);
    
    latch.wait(); // 主线程等待，直到计数器为0
    
    t1.join();
    t2.join();
    t3.join();
    return 0;
}