实现一个固定长度的同步队列

实现一个固定长度的同步队列，支持以下功能：

1、向队列中添加元素，包括阻塞和非阻塞两种接口；

2、从队列中获取元素，包括阻塞和非阻塞两种接口；

3、获取队列当前元素个数

此外需要保证：

1、接口线程安全；

2、队列可被正确释放；

#include <iostream>
#include <memory> 
#include <mutex>
#include <condition_variable>
#include <queue>
using namespace std;

template <typename T, size_t Capacity>
struct SyncQueue {
public:

	SyncQueue() {};

	~SyncQueue() {
		unique_lock<std::mutex> lock(mutex);
		cv.wait(lock, [this]() { return queue.empty(); });
	}

	// 阻塞添加元素
	void addqueue(const T& item) {
		unique_lock<std::mutex> lock(mutex);
		while (queue.size() >= Capacity) {
			cv.wait(lock);
		}
		queue.push(item);
		cv.notify_one();
	}

	// 非阻塞添加元素
	bool tryaddqueue(const T& item) {
		lock_guard<std::mutex> lock(mutex);
		if (queue.size() >= Capacity) {
			return false; // 队列已满
		}
		queue.push(item);
		return true;
	}

	// 阻塞获取元素
	T dequeue() {
		unique_lock<std::mutex> lock(mutex);
		while (queue.empty()) {
			cv.wait(lock);
		}
		T item = queue.front();
		queue.pop();
		cv.notify_one();
		return item;
	}

	// 非阻塞获取元素
	bool trydequeue(T& item) {
		lock_guard<std::mutex> lock(mutex);
		if (queue.empty()) {
			return false; // 队列为空
		}
		item = queue.front();
		queue.pop();
		return true;
	}

	// 获取队列中元素的数量
	size_t size() const {
		lock_guard<std::mutex> lock(mutex);
		return queue.size();
	}

private:
	//私有定义互斥锁、条件变量、同步队列
	mutable mutex mutex; 
	condition_variable cv; 
	queue<T> queue; 
};

int main() {
	SyncQueue<int, 10> queue;

	// 模拟生产者
	thread producer([&queue]() {
		for (int i = 0; i < 100; ++i) {
			queue.addqueue(i);
			std::cout << "Produced-->: " << i << std::endl;
		}
	});

	// 模拟消费者
	thread consumer([&queue]() {
		for (int i = 0; i < 100; ++i) {
			int item = queue.dequeue();
			std::cout << "Consumed-->: " << item << std::endl;
		}
	});

	producer.join();
	consumer.join();

	return 0;
}