你知道如何在C++ 中实现线程安全的数据结构吗？

概述：多线程是计算机科学中一个强大的概念，它允许多个线程在单个程序中并发执行。每个线程都表示一个独立的执行流，共享相同的资源，包括内存空间。虽然多线程可以通过利用多个处理器内核来显著提高性能，但它带来了与数据安全一致性相关的挑战。对线程安全数据结构的需求在多线程环境中，多个线程可以同时访问和修改共享数据，确保数据完整性变得至关重要。如果没有适当的同步，共享数据结构上的并发操作可能会导致争用条件、数据损坏和其他不可预测的行为。线程安全至关重要的一种常见方案是并发数据结构（如队列）的实现。线程安全队列可确保多个线程可以安全地对元素进行排队和取消排队，而不会导致数据丢失、损坏或其他同步问题。线程安全队列实

多线程是计算机科学中一个强大的概念，它允许多个线程在单个程序中并发执行。每个线程都表示一个独立的执行流，共享相同的资源，包括内存空间。虽然多线程可以通过利用多个处理器内核来显著提高性能，但它带来了与数据安全一致性相关的挑战。

对线程安全数据结构的需求

在多线程环境中，多个线程可以同时访问和修改共享数据，确保数据完整性变得至关重要。如果没有适当的同步，共享数据结构上的并发操作可能会导致争用条件、数据损坏和其他不可预测的行为。

线程安全至关重要的一种常见方案是并发数据结构（如队列）的实现。线程安全队列可确保多个线程可以安全地对元素进行排队和取消排队，而不会导致数据丢失、损坏或其他同步问题。

线程安全队列实现

在本文中，我们将深入探讨在 C++ 中实现线程安全队列的技术细节。我们将使用该类，该类提供对多线程环境中队列的安全访问。ThreadSafeQueue

让我们分析一下实现的关键组件。ThreadSafeQueue

互斥和锁定

使用 a 提供对共享数据结构的独占访问。互斥锁确保在任何给定时间只有一个线程可以修改队列的内部状态。用于简化锁定机制，即使在存在异常的情况下也能确保正确解锁。ThreadSafeQueuestd::mutexstd::scoped_lock

mutable std::mutex mtx;

条件变量

用于线程之间的高效等待和信号传递。它允许线程有效地等待数据可用的通知。当新元素被推送到队列中时，等待的线程将通过条件变量唤醒。std::condition_variable

std::condition_variable data_cond;

用于内存管理的智能指针

的使用是实现的一个关键方面。在队列中推送的每个元素都使用 动态分配。这可确保正确的内存管理并防止内存泄漏。共享所有权语义允许多个线程安全地访问相同的动态分配内存。std::shared_ptrstd::allocate_sharedstd::shared_ptr

std::queue<std::shared_ptr<T>> data_queue;

推送操作

该操作负责向队列添加新元素。它使用 为元素分配内存，锁定互斥锁以确保独占访问，将新元素推送到队列中，并通过条件变量通知等待线程。pushstd::allocate_shared

void push(T new_value) {  
    std::shared_ptr<T> data(std::allocate_shared<T>(allocator, std::move(new_value)));  
    std::scoped_lock lk(mtx);  
    data_queue.push(data);  
    data_cond.notify_one();  
}

等待和弹出操作

该操作旨在安全地从队列中弹出元素。它使用 a 来锁定互斥锁，并在队列为空时有效地等待通知。收到通知后，它会检索 front 元素，将其从队列中弹出，并返回指向该元素的共享指针。wait_and_popstd::unique_lock

std::shared_ptr<T> wait_and\_pop() {  
    std::unique_lock lk(mtx);  
    data_cond.wait(lk, [this] { return !data_queue.empty(); });  
    std::shared_ptr<T> res = data_queue.front();  
    data_queue.pop();  
    return res;  
}

尝试 Pop 操作

该操作提供非阻塞尝试，以从队列中弹出一个 elment。它会锁定互斥锁，检查队列是否为空，如果不是，则从队列前面移动值并弹出它。使用可确保正确锁定和解锁。try_popstd::scoped_lock

bool try_pop(T& value) {  
    std::scoped_lock lk(mtx);  
    if (data_queue.empty()) {  
        return false;  
    }  
    value = std::move(*data_queue.front());  
    data_queue.pop();  
    return true;  
}

用法示例

让我们举例说明 with 多个 producet 和 consumer 线程的用法。ThreadSafeQueue

int main() {
    ThreadSafeQueue<int> tsQueue;

    // Number of producers
    const int numProducers = 3;

    // Multiple producer threads pushing elements
    std::vector<std::thread> producers;
    for (int i = 0; i < numProducers; ++i) {
        producers.emplace_back([&tsQueue, i]() {
            for (int j = 0; j < 10; ++j) {
                int value = i * 100 + j;
                tsQueue.push(value);
                std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Simulate some work
            }
        });
    }

    // Single consumer thread popping elements
    std::thread consumer([&tsQueue]() {
        for (int i = 0; i < 30; ++i) {
            auto value = tsQueue.wait_and_pop();
            if (value) {
                std::cout << "Dequeued: " << *value << std::endl;
            }
        }
    });

    // Join all producer threads and the consumer thread
    for (auto& producer : producers) {
        producer.join();
    }
    consumer.join();

    return 0;
}

在提供的示例中，我们模拟了一个具有多个生产者线程和一个与 交互的消费者线程的场景。下面是示例的细分：ThreadSafeQueue

ThreadSafeQueue 初始化

将创建一个 named 实例，用作共享数据结构ThreadSafeQueue<int>tsQueue

ThreadSafeQueue<int> tsQueue;

多个生产者

生成指定数量的生产者线程 （ ），每个线程将 10 个唯一值推送到队列中，每次推送之间的延迟为 100 毫秒。生成这些值是为了展示每个生产者的不同贡献numProducers

const int numProducers = 3;
for (int i = 0; i < numProducers; ++i) {
    producers.emplace_back([&tsQueue, i]() {
        for (int j = 0; j < 10; ++j) {
            int value = i * 100 + j;
            tsQueue.push(value);
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    });
}

单一消费者

单个使用者线程使用该操作从队列中弹出元素。在此示例中，使用者尝试将 30 个元素取消排队。wait_and_pop

std::thread consumer([&tsQueue]() {
    for (int i = 0; i < 30; ++i) {
        auto value = tsQueue.wait_and_pop();
        if (value) {
            std::cout << "Dequeued: " << *value << std::endl;
        }
    }
});

连接线程

主线程通过调用 来等待所有生产者和使用者线程完成其执行。join()

for (auto& producer : producers) {  
    producer.join();  
}  
consumer.join();

此示例演示了多个生产者和单个使用者之间的协调交互。同步机制和智能指针可确保数据结构保持线程安全，防止在并发访问期间丢失或损坏数据。ThreadSafeQueue

线程安全队列的实现涉及使用互斥锁和条件变量进行仔细同步。智能指针在管理动态内存和确保跨多个线程的安全所有权方面发挥着至关重要的作用。此处介绍的方案为多个线程需要安全地对元素进行排队和取消排队的情况提供了一个可靠的解决方案，从而防止数据损坏和争用条件。

如果你喜欢我的文章，请给我一个赞！谢谢