C++编程语言是一种广泛使用的高级编程语言，其提供了各种各样的数据结构和算法。双向队列（Deque）作为一种特殊形式的队列，既可以用作栈，又可以用作队列。在实际应用中，双向队列的使用频率相当高。然而，C++中的双向队列并不是线程安全的数据结构，可能会出现多线程访问同一个双向队列的情况。为了解决这个问题，我们需要实现一个线程安全的双向队列。

线程安全的双向队列使用锁和条件变量来确保多个线程可以安全地访问它。下面是线程安全的双向队列的实现：

#include <deque>
#include <mutex>
#include <condition_variable>
template<typename T>
class ThreadSafeDeque {
private:
  std::deque<T> m_deque;
  std::mutex m_mutex;
  std::condition_variable m_cond;
public:
  ThreadSafeDeque() {}
  void push_front(const T& item) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_deque.push_front(item);
    m_cond.notify_one();
  }
  void push_back(const T& item) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_deque.push_back(item);
    m_cond.notify_one();
  }
  bool try_pop_front(T& item) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if(m_deque.empty())
      return false;
    
    item = m_deque.front();
    m_deque.pop_front();
    return true;
  }
  bool try_pop_back(T& item) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if(m_deque.empty())
      return false;
    
    item = m_deque.back();
    m_deque.pop_back();
    return true;
  }
  void wait_and_pop_front(T& item) {
    std::unique_lock<std::mutex> lock(m_mutex);
    m_cond.wait(lock, [this]() { return !m_deque.empty(); });
    item = m_deque.front();
    m_deque.pop_front();
  }
  void wait_and_pop_back(T& item) {
    std::unique_lock<std::mutex> lock(m_mutex);
    m_cond.wait(lock, [this]() { return !m_deque.empty(); });
    item = m_deque.back();
    m_deque.pop_back();
  }
};

以上代码使用deque来存储数据。使用std::mutex来保证任意时刻只有一个线程可以访问队列。这些方法被包装在锁保持期间实例化的std::lock_guard对象中，以确保在调用这些方法时，已经有一个可用的锁来保护双向队列。同时，在添加或删除元素后，通过m_cond.notify_one()通知一个正在等待的线程，以防止线程阻塞。

例如，调用wait_and_pop_front方法会进入线程阻塞，直到有元素可供使用，它会等待线程条件变量m_cond。当另一个线程调用push_front或push_back之一时，线程条件变量m_cond将会被通知，唤醒正在等待的线程，以便该线程可以获得队列中的元素，并执行所需的操作。

总之，线程安全的双向队列提供了一种低耗且可靠的多线程编程解决方案。在多线程环境中使用这种安全的数据结构，可以更轻松地编写高质量的代码。

相似文章
• Java实现双向链表的方法及应用场景
  Java实现双向链表的方法及应用场景
  
  

友情链接
• 网站定制开发
• 帮你发
• 小蓄群站获客
• 雅圣洁家政