Linux環境下C++多線程同步方法

在Linux環境下，C++多線程同步主要有以下幾種方法：

1. 互斥鎖（mutex）：互斥鎖是一種用于保護共享資源的同步原語。當一個線程訪問共享資源時，它需要先鎖定互斥鎖，其他線程在互斥鎖被解鎖之前無法訪問該資源。C++11提供了std::mutex類來實現互斥鎖。

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

std::mutex mtx;

void print_block(int n, char c) {
    mtx.lock();
    for (int i = 0; i < n; ++i) {
        std::cout << c;
    }
    std::cout << '\n';
    mtx.unlock();
}

int main() {
    std::thread th1(print_block, 50, '*');
    std::thread th2(print_block, 50, '$');

    th1.join();
    th2.join();

    return 0;
}

2. 遞歸互斥鎖（recursive mutex）：遞歸互斥鎖允許同一個線程多次鎖定同一個互斥鎖，而不會導致死鎖。C++11提供了std::recursive_mutex類來實現遞歸互斥鎖。

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

std::recursive_mutex mtx;

void foo() {
    mtx.lock();
    std::cout << "foo\n";
    mtx.lock(); // 同一個線程可以再次鎖定遞歸互斥鎖
    std::cout << "foo again\n";
    mtx.unlock();
    mtx.unlock();
}

int main() {
    std::thread t(foo);
    t.join();
    return 0;
}

3. 條件變量（condition variable）：條件變量允許線程在某個條件滿足時等待，并在條件改變時被喚醒。C++11提供了std::condition_variable類來實現條件變量。

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

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

void print_id(int id) {
    std::unique_lock<std::mutex> lck(mtx);
    cv.wait(lck, []{return ready;}); // 等待條件滿足
    std::cout << "thread " << id << '\n';
}

void go() {
    std::unique_lock<std::mutex> lck(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::this_thread::sleep_for(std::chrono::seconds(1));
    go();

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

    return 0;
}

4. 讀寫鎖（shared mutex）：讀寫鎖允許多個線程同時讀取共享資源，但只允許一個線程寫入共享資源。C++17提供了std::shared_mutex類來實現讀寫鎖。

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

std::shared_mutex rw_mtx;

void read_data(int id) {
    std::shared_lock<std::shared_mutex> lck(rw_mtx);
    std::cout << "reader " << id << '\n';
}

void write_data(int id) {
    std::unique_lock<std::shared_mutex> lck(rw_mtx);
    std::cout << "writer " << id << '\n';
}

int main() {
    std::thread readers[5], writers[5];

    for (int i = 0; i < 5; ++i) {
        readers[i] = std::thread(read_data, i);
        writers[i] = std::thread(write_data, i);
    }

    for (auto &th : readers) {
        th.join();
    }
    for (auto &th : writers) {
        th.join();
    }

    return 0;
}

這些同步方法可以幫助你在Linux環境下實現C++多線程同步。在實際應用中，你需要根據具體需求選擇合適的同步方法。