Linux C++多线程与并发数据结构的实现

在Linux环境下，使用C++实现多线程和并发数据结构需要依赖于一些库和工具，如POSIX线程库（pthread）和C++11标准中的线程支持

1. 多线程的实现：

在Linux环境下，可以使用POSIX线程库（pthread）来实现多线程。以下是一个简单的C++多线程示例：

#include <iostream>
#include <pthread.h>

void* print_hello(void* arg) {
    std::cout << "Hello from thread " << pthread_self() << std::endl;
    return nullptr;
}

int main() {
    pthread_t threads[5];
    int rc;

    for (int i = 0; i < 5; ++i) {
        rc = pthread_create(&threads[i], nullptr, print_hello, nullptr);
        if (rc != 0) {
            std::cerr << "Error creating thread "<< i << std::endl;
            return 1;
        }
    }

    for (int i = 0; i < 5; ++i) {
        pthread_join(threads[i], nullptr);
    }

    return 0;
}

2. 并发数据结构的实现：

在Linux环境下，可以使用C++11标准中的线程支持来实现并发数据结构。以下是一个简单的线程安全队列示例：

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

template <typename T>
class ThreadSafeQueue {
public:
    void push(const T& value) {
        std::unique_lock<std::mutex> lock(mutex_);
        queue_.push(value);
        lock.unlock();
        cond_var_.notify_one();
    }

    bool pop(T& value) {
        std::unique_lock<std::mutex> lock(mutex_);
        while (queue_.empty()) {
            cond_var_.wait(lock);
        }
        value = queue_.front();
        queue_.pop();
        return true;
    }

private:
    std::queue<T> queue_;
    std::mutex mutex_;
    std::condition_variable cond_var_;
};

void producer(ThreadSafeQueue<int>& queue) {
    for (int i = 0; i < 10; ++i) {
        queue.push(i);
        std::cout << "Produced: "<< i << std::endl;
    }
}

void consumer(ThreadSafeQueue<int>& queue) {
    int value;
    for (int i = 0; i < 10; ++i) {
        if (queue.pop(value)) {
            std::cout << "Consumed: " << value << std::endl;
        }
    }
}

int main() {
    ThreadSafeQueue<int> queue;
    std::thread producer_thread(producer, std::ref(queue));
    std::thread consumer_thread(consumer, std::ref(queue));

    producer_thread.join();
    consumer_thread.join();

    return 0;
}

在这个示例中，我们实现了一个线程安全的队列，它使用互斥锁（mutex）来保护队列的访问，并使用条件变量（condition_variable）来实现线程间的同步。生产者线程向队列中添加元素，消费者线程从队列中取出元素。通过这种方式，我们可以实现一个简单的并发数据结构。