C++中线程同步与互斥的四种方式介绍及对比详解

#include <thread>
#include <mutex>

std::mutex mtx;  // 全局互斥量
int shared_data = 0;  // 共享数据

void thread_func() {
    for (int i = 0; i < 10000; ++i) {
        mtx.lock();  // 获取互斥量的所有权
        ++shared_data;  // 修改共享数据
        mtx.unlock();  // 释放互斥量的所有权
    }
}

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

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

    std::cout << shared_data << std::endl;  // 输出20000

    return 0;
}

#include <thread>
#include <mutex>

std::mutex mtx;  // 全局互斥量
int shared_data = 0;  // 共享数据

void thread_func() {
    for (int i = 0; i < 10000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);  // 创建锁，自动获取互斥量的所有权
        ++shared_data;  // 修改共享数据
        // 锁在离开作用域时自动释放互斥量的所有权
    }
}

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

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

    std::cout << shared_data << std::endl;  // 输出20000

    return 0;
}

#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);  // 创建锁，自动获取互斥量的所有权
    while (!ready) {  // 如果条件不满足
        cv.wait(lock);  // 等待条件变量的通知
    }
    // 当收到条件变量的通知，且条件满足时，继续执行
    std::cout << "thread " << id << '\n';
}

void go() {
    std::unique_lock<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::cout << "10 threads ready to race...\n";
    go();  // 开始比赛

    for (auto& th : threads) th.join();

    return 0;
}

#include <thread>
#include <atomic>

std::atomic<int> shared_data(0);  // 共享数据

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

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

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

    std::cout << shared_data << std::endl;  // 输出20000

    return 0;
}

#include <thread>
#include <mutex>
#include <atomic>

std::mutex mtx;  // 全局互斥量
std::atomic<int> counter(0);  // 原子计数器

void thread_func() {
    for (int i = 0; i < 10000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);  // 获取互斥量的所有权
        ++counter;  // 原子操作
        // 锁在离开作用域时自动释放互斥量的所有权
    }
}

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

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

    std::cout << counter << std::endl;  // 输出20000

    return 0;
}