Потокобезопасная очередь

#include <stdlib.h>
#include <stdint.h>
#include <iostream>
#include <mutex>
#include <condition_variable>
#include <cassert>
 
 
template<typename T, int32_t MAX_SIZE_QUEUE = 256>
class BoundedQueue {
 public:
  BoundedQueue() : start(MAX_SIZE_QUEUE - 1), end(MAX_SIZE_QUEUE - 1) {}
 
  void Enqueue(const T &value) {
    if (abs(end - start) >= MAX_SIZE_QUEUE) { return; }
    data[end] = value;
    end = --end % MAX_SIZE_QUEUE;
  }
 
  void Dequeue(T *out_value) {
    if (!out_value || Empty()) { return; }
    *out_value = data[start];
    start = --start % MAX_SIZE_QUEUE;
  }
 
  bool Empty() const {
    return start == end;
  }
 
 private:
  int start;
  int end;
  T data[MAX_SIZE_QUEUE];
};
 
template<typename T, int32_t MAX_SIZE_QUEUE = 256>
class ThreadSafeQueue {
 public:
  ThreadSafeQueue() {}
 
  ThreadSafeQueue(const ThreadSafeQueue &) = delete;
  ThreadSafeQueue &operator=(const ThreadSafeQueue &) = delete;
 
  void Push(T new_value) {
    std::lock_guard<std::mutex> lk(mutex);
    data_queue.Enqueue(new_value);
    data_cond.notify_all();
  }
 
  void WaitAndPop(T *value) {
    std::unique_lock<std::mutex> lk(mutex);
    data_cond.wait(lk, [this] { return !data_queue.Empty(); });
    data_queue.Dequeue(value);
  }
 
  bool Empty() const {
    std::lock_guard<std::mutex> lk(mutex);
    return data_queue.Empty();
  }
 
 private:
  mutable std::mutex mutex;
  std::condition_variable data_cond;
  BoundedQueue<T, MAX_SIZE_QUEUE> data_queue;
};
 
int main() {
  std::cout << "Hello, World!" << std::endl;
 
  ThreadSafeQueue<int, 256> queue;
  for (int i = 0; i < 256; ++i) {
    queue.Push(i);
  }
 
  for (int i = 0; i < 256; ++i) {
    int result = 0;
    queue.WaitAndPop(&result);
    printf("result:%i == i:%i\n", result, i);
    assert(result == i);
  }
 
  return 0;
}

template <typename T, int32_t MAX_SIZE_QUEUE = 256>
class BoundedQueue {
 public:
  BoundedQueue() : start(MAX_SIZE_QUEUE - 1), end(MAX_SIZE_QUEUE - 1) {}
 
  void Enqueue(const T& value) {
    if (abs(end - start) == MAX_SIZE_QUEUE) { return; }
    data[end--] = value;
  }
 
  void Dequeue(T* out_value) {
    if (!out_value || Empty()) { return; }
    *out_value = data[start--];
  }
 
  bool Empty() const {
    return start == end;
  }
 
 private:
  int start;
  int end;
  T data[MAX_SIZE_QUEUE];
};

template <typename T, int32_t MAX_SIZE_QUEUE = 256>
class BoundedQueue {
 public:
  BoundedQueue() : start(0), end(0) {}
 
  void Enqueue(const T& value) {
    if (end == MAX_SIZE_QUEUE) { return; }
    data[end++] = value;
  }
 
  void Dequeue(T* out_value) {
    if (!out_value || Empty()) { return; }
    *out_value = data[start++];
  }
 
  bool Empty() const {
    return (start == end);
  }
 
 private:
  int start;
  int end;
  T data[MAX_SIZE_QUEUE];
};