【多线程/C++】阻塞队列的C++多线程 实现 BlockingQueue

阻塞队列在存放和获取队列中的数据时需要使用多线程，一个线程专门负责向队列中存放元素，另一个线程专门从队列中获取元素。也可多开辟跟多的线程进行存取。

规范的方法也正是存放和获取队列元素分别在不同的线程中实现。

阻塞队列实现：

1. 当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素；

2. 当队列满时，有两种方案：

• 方案1： 往队列里存放元素的操作也会被阻塞，直到有元素被从队列中取出或者删除。
  具体方法：定义一个条件变量std::condition_variable not_full_;在存放操作时，判断队列为满时,使用not_full_.wait(lock)阻塞线程；当进行删除队列元素的操作后，就使用not_full_.notify_all()来唤醒not_full_.wait(lock)的线程。

  【注意区分： 条件变量not_empty_是在获取数据时判断队列是否为空，为空时，使用not_empty_.wait(lock); ，当有队列有新数据进来才会not_empty_.notify_all();唤醒not_empty_.wait(lock);的线程。 存放操作和获取操作需要使用不同的条件变量进行阻塞等待和唤醒】

• 方案2： 不使用阻塞，而是直接删除队列中最老的元素，删除后就直接往队列添加元素了。【本文示例就是方案2】

以上的操作都是基于不同的线程来说的，线程在对阻塞队列进程操作时会被阻塞。

#pragma once

#include <condition_variable>
#include <deque>
#include <mutex>
#include <string>
#include <thread>
#include <list>
#include <vector>

template <typename T>
class BlockingQueue {
 public:
  BlockingQueue(uint size) : size_(size) {}
  BlockingQueue() {}

  /**
   * @brief 向队列中push_back一个元素
   * **/
  void put(const T x) {
    std::unique_lock<std::mutex> lock(mutex_);
    if (size_ != 0 && queue_.size() > size_) {
      queue_.pop_front();
    }
    queue_.push_back(std::move(x));
    not_empty_.notify_all();  //有新数据push进来后就唤醒所有wait的线程
  }

  /**
   * @brief 获取队列中第一个元素（不是最新元素）
   * 元素一旦获取，就从队列中删除
   * **/
  T take() {
    std::unique_lock<std::mutex> lock(mutex_);
    while (queue_.empty()) {
      not_empty_.wait(lock);  //如果队列为空，线程就在此阻塞挂起，等待唤醒
    }
    const T front = queue_.front();
    queue_.pop_front();
    return front;
  }

  /**
   * @brief 取出队列中所有元素(取出后就从队列中删除),并push_back到一个vector中
   * **/
  int take(std::vector<T> *v, size_t count) {
    std::unique_lock<std::mutex> lock(mutex_);
    while (queue_.empty()) {
      not_empty_.wait(lock);  //如果队列为空，线程就在此阻塞挂起，等待唤醒
    }
    while (!queue_.empty() && count--) {
      v->push_back(queue_.front());
      queue_.pop_front();
    }

    return v->size();
  }

  /**
   * @brief 根据索引获取队列中对应元素
   * **/
  T get(size_t index) {
    std::unique_lock<std::mutex> lock(mutex_);
    while (queue_.empty()) {
      not_empty_.wait(lock);
    }
    return queue_.at(index);
  }

  /**
   * @brief 获取队列元素个数
   * **/
size_t size() const {
    std::unique_lock<std::mutex> lock(mutex_);
    return queue_.size();
  }

 private:
  mutable std::mutex mutex_;
  std::condition_variable not_empty_;
  std::deque<T> queue_;
  // std::list<T> queue_;//双向链表
  
  uint size_ = 0;
};