C++多線程在Linux下的線程安全集合操作

在Linux下，使用C++多線程時，線程安全集合操作是非常重要的

1. 使用互斥鎖（std::mutex）：

互斥鎖是最基本的同步原語，用于確保在同一時刻只有一個線程可以訪問共享資源。C++標準庫提供了std::mutex類，可以用來保護共享數據。

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

std::mutex mtx;
std::vector<int> shared_data;

void add_data(int value) {
    std::lock_guard<std::mutex> lock(mtx);
    shared_data.push_back(value);
}

int main() {
    std::thread t1(add_data, 1);
    std::thread t2(add_data, 2);

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

    for (int value : shared_data) {
        std::cout << value << " ";
    }

    return 0;
}

2. 使用原子操作（std::atomic）：

原子操作是一種特殊的操作，可以在不使用鎖的情況下保證線程安全。C++標準庫提供了std::atomic模板類，可以用來保護簡單的數據類型。

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

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

void add_data(int value) {
    int index = counter.fetch_add(1);
    shared_data[index] = value;
}

int main() {
    std::thread t1(add_data, 1);
    std::thread t2(add_data, 2);

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

    for (int value : shared_data) {
        std::cout << value << " ";
    }

    return 0;
}

3. 使用線程安全容器（std::concurrent_queue）：

C++標準庫提供了std::concurrent_queue模板類，這是一個線程安全的隊列實現，可以在多線程環境下安全地使用。

#include <iostream>
#include <thread>
#include <concurrent_queue>

std::concurrent_queue<int> shared_queue;

void add_data(int value) {
    shared_queue.push(value);
}

void process_data() {
    int value;
    while (true) {
        if (shared_queue.try_pop(value)) {
            std::cout << value << " ";
        } else {
            std::this_thread::yield();
        }
    }
}

int main() {
    std::thread t1(add_data, 1);
    std::thread t2(add_data, 2);
    std::thread t3(process_data);

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

    return 0;
}

注意：std::concurrent_queue不支持迭代器，因此不能像其他容器那樣遍歷它。在使用時，需要根據具體需求選擇合適的線程安全集合操作。