Multithreaded Queue

mt_queue.hpp

#pragma once

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

template <typename T>
class queue_mt
{
public:
	T& front()
	{
		std::unique_lock<std::mutex> ulock(m_mutex);

		while (m_queue.empty())
		{
			m_cv.wait(ulock);
		}

		return m_queue.front();
	}

	T popoff()
	{
		std::unique_lock<std::mutex> ulock(m_mutex);

		while (m_queue.empty())
		{
			m_cv.wait(ulock);
		}

		const auto val = m_queue.front();
		m_queue.pop();
		return val;
	}

	void pop()
	{
		std::unique_lock<std::mutex> ulock(m_mutex);

		while (m_queue.empty())
		{
			m_cv.wait(ulock);
		}

		m_queue.pop();
	}

	void push(const T& item)
	{
		std::unique_lock<std::mutex> ulock(m_mutex);
		m_queue.push(item);
		ulock.unlock();
		m_cv.notify_one();
	}

	void push(T&& item)
	{
		std::unique_lock<std::mutex> ulock(m_mutex);
		m_queue.push(std::move(item));
		ulock.unlock();
		m_cv.notify_one();
	}

	size_t size()
	{
		std::unique_lock<std::mutex> ulock(m_mutex);
		const auto sz = m_queue.size();
		ulock.unlock();
		return sz;
	}

	bool empty()
	{
		std::unique_lock<std::mutex> ulock(m_mutex);
		const auto isEmpty = m_queue.empty();
		ulock.unlock();
		return isEmpty;
	}

protected:
	std::queue<T> m_queue;
	std::mutex m_mutex;
	std::condition_variable m_cv;
};