Linux C++多线程同步机制详解

在 Linux 系统中，C++ 多线程同步机制是确保多个线程之间正确并发执行的关键

1. 互斥锁（Mutex）：互斥锁是一种同步原语，用于确保多个线程在访问共享资源时不会发生冲突。C++11 提供了 std::mutex 类来实现互斥锁。使用 std::lock_guard 或 std::unique_lock 可以自动管理锁的获取和释放。

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

std::mutex mtx; // 全局互斥锁

void print_block(int n, char c) {
    std::lock_guard<std::mutex> lock(mtx); // 自动加锁
    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << std::endl;
    // 自动解锁
}

int main() {
    std::thread t1(print_block, 50, '*');
    std::thread t2(print_block, 50, '$');

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

    return 0;
}

2. 条件变量（Condition Variable）：条件变量是一种用于线程间通信的同步原语。C++11 提供了 std::condition_variable 类来实现条件变量。使用 std::unique_lock 可以自动管理锁的获取和释放。

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

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

void print_block(int n, char c) {
    std::unique_lock<std::mutex> lock(mtx);
    while (!ready) { // 如果 ready 为 false，则等待
        cv.wait(lock); // 释放锁并等待条件变量
    }
    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << std::endl;
    // 恢复 ready 为 true
    ready = false;
    cv.notify_one(); // 唤醒等待的线程
}

int main() {
    std::thread t1(print_block, 50, '*');
    std::thread t2(print_block, 50, '$');

    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true; // 设置 ready 为 true
    }
    cv.notify_all(); // 唤醒所有等待的线程

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

    return 0;
}

3. 读写锁（Read-Write Lock）：读写锁是一种允许多个线程同时读取共享资源，但在写入时会阻止其他线程访问的同步原语。C++17 提供了 std::shared_mutex 类来实现读写锁。使用 std::shared_lock 和 std::unique_lock 可以自动管理锁的获取和释放。

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <vector>

std::shared_mutex rw_mtx; // 全局读写锁
int data = 0;

void read_block() {
    std::shared_lock<std::shared_mutex> lock(rw_mtx); // 获取共享锁
    std::cout << "Read: " << data << std::endl;
    // 释放共享锁
}

void write_block(int value) {
    std::unique_lock<std::shared_mutex> lock(rw_mtx); // 获取独占锁
    data = value;
    std::cout << "Write: " << data << std::endl;
    // 释放独占锁
}

int main() {
    std::thread t1(read_block);
    std::thread t2(read_block);
    std::thread t3(write_block, 42);

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

    return 0;
}

这些同步机制可以确保在多线程环境下正确地访问和修改共享资源。在实际应用中，可以根据具体需求选择合适的同步机制。