利用互斥锁设计线程安全队列

/*
 * @Description: 利用互斥锁设计线程安全队列
 * @Version: 1.0
 * @Author: hanhy
 */

#ifndef CONCURRENCY_L_THREADSAFEQUEUE_H
#define CONCURRENCY_L_THREADSAFEQUEUE_H

#include <condition_variable>
#include <memory>
#include <mutex>
#include <queue>

template <typename T> class ThreadSafeQueue {
private:
  mutable std::mutex mtx_; //标记为mutable可以在bool empty() const中使用
  std::queue<T> queue_;
  std::condition_variable condition_variable_;

public:
  ThreadSafeQueue()= default;

  ThreadSafeQueue(const ThreadSafeQueue &other) {
    std::lock_guard<std::mutex> lk(other.mtx_);
    queue_ = other.queue_;
  }

  void push(T new_value) {
    std::lock_guard<std::mutex> lk(mtx_);
    queue_.push(new_value);
    condition_variable_.notify_one();
  }

  void wait_and_pop(T &value) {
    std::unique_lock<std::mutex> lk(mtx_);
    condition_variable_.wait(lk, [this] { return !queue_.empty(); });
    value = queue_.front();
    queue_.pop();
  }

  std::shared_ptr<T> wait_and_pop() {
    std::unique_lock<std::mutex> lk(mtx_);
    condition_variable_.wait(lk, [this] { return !queue_.empty(); });
    std::shared_ptr<T> res(std::make_shared<T>(queue_.front()));
    queue_.pop();
    return res;
  }

  bool try_pop(T &value) {
    std::lock_guard<std::mutex> lk(mtx_);
    if (queue_.empty())
      return false;
    value = queue_.front();
    queue_.pop();
    return true;
  }

  std::shared_ptr<T> tyr_pop() {
    std::lock_guard<std::mutex> lk(mtx_);
    if (queue_.empty())
      return std::shared_ptr<T>();
    std::shared_ptr<T> res(std::make_shared<T>(queue_.front()));
    queue_.pop();
    return res;
  }

  bool empty() const {
    std::lock_guard<std::mutex> lk(mtx_);
    return queue_.empty();
  }
};

#endif // CONCURRENCY_L_THREADSAFEQUEUE_H