C++怎么使用多线程同步 C++多线程同步的几种机制对比

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

std::mutex mtx; // 定义一个互斥锁
int counter = 0;

void increment() {
    for (int i = 0; i < 10000; ++i) {
        mtx.lock(); // 加锁
        counter++;
        mtx.unlock(); // 解锁
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

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

    std::cout << "Counter value: " << counter << std::endl; // 预期结果：20000
    return 0;
}

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

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

void worker_thread() {
    std::unique_lock<std::mutex> lock(mtx); // 自动解锁的互斥锁
    cv.wait(lock, []{ return ready; }); // 等待条件满足
    std::cout << "Worker thread is processing..." << std::endl;
}

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

int main() {
    std::thread worker(worker_thread);
    std::thread signaler(signal_ready);

    worker.join();
    signaler.join();

    return 0;
}

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 10000; ++i) {
        counter++; // 原子操作
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

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

    std::cout << "Counter value: " << counter << std::endl; // 预期结果：20000
    return 0;
}

#include <iostream>
#include <thread>
#include <shared_mutex> // C++17引入

std::shared_mutex rw_mutex;
int data = 0;

void reader() {
    for (int i = 0; i < 5; ++i) {
        std::shared_lock<std::shared_mutex> lock(rw_mutex); // 共享锁
        std::cout << "Reader: " << data << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void writer() {
    for (int i = 0; i < 3; ++i) {
        std::unique_lock<std::shared_mutex> lock(rw_mutex); // 独占锁
        data++;
        std::cout << "Writer: " << data << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }
}

int main() {
    std::thread t1(reader);
    std::thread t2(writer);
    std::thread t3(reader);

    t1.join();
    t2.join();
    t3.join();

    return 0;
}

#include <iostream>
#include <thread>
#include <semaphore>

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

void worker(int id) {
    semaphore.acquire(); // 获取信号量
    std::cout << "Thread " << id << " is working..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Thread " << id << " is done." << std::endl;
    semaphore.release(); // 释放信号量
}

int main() {
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);
    std::thread t3(worker, 3);
    std::thread t4(worker, 4);
    std::thread t5(worker, 5);

    t1.join();
    t2.join();
    t3.join();
    t4.join();
    t5.join();

    return 0;
}