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不支持迭代器，因此不能像其他容器那样遍历它。在使用时，需要根据具体需求选择合适的线程安全集合操作。