#include <iostream>
#include <memory>
#include <mutex>
#include <condition_variable>
#include <atomic>
 
 
typedef ::std::unique_lock<::std::mutex> TLock;
 
using namespace std;
template<typename T>
class TQueueElement
{
public:
	T _data;
	std::shared_ptr<TQueueElement<T> > _prev;
	mutable ::std::mutex _lockElem;
 
public:
	TQueueElement(T data):_data(data),_prev(nullptr){};
	virtual ~TQueueElement(){};
 
 
};
 
template<typename T>
class TQueue
{
private:
	mutable ::std::mutex _lockHead;
	mutable ::std::mutex _lockTail;
	::std::condition_variable _pushToQueue;
	std::atomic<bool> _isEmpty;
	std::shared_ptr<TQueueElement<T> > _tail;
	std::shared_ptr<TQueueElement<T> > _head;
 
public:
	TQueue():_lockHead(),_isEmpty(true){};
	virtual ~TQueue(){};
 
///получаем элемент из очереди
	T pop()
	{
		TLock lock(_lockTail);//блокируем все получения из очереди
		if (_tail==nullptr) 
		{
			TLock lockHead(_lockHead);
			if (_tail==nullptr) 
			{
				_isEmpty=true; 
				lockHead.unlock();
				_pushToQueue.wait(lock,[this](){return !_isEmpty;});//если очередь пуста ожидаем пока в ней чтото появиться 
			}
		} 
		{
			TLock lockTail(_tail->_lockElem); //блокируем последний элемент в очереди возможно к нему попробуют обратиться во время запихивания в очередь
			auto data=_tail->_data;
			_tail=_tail->_prev;
			return data;
		}
 
	}
 
	void push(T data)
	{
		auto el=std::shared_ptr<TQueueElement<T> >(new TQueueElement<T>(data));//заранее создаем элемент очереди 
		TLock lock(_lockHead);
		if (_isEmpty)//если очередь пуста говорим что наш элемент пока первый и последний
		{
			{
				TLock lock(_lockTail);	
				_head=el;
				_tail=el;
				_isEmpty=false;
			}
			_pushToQueue.notify_all();
		}else//если очередь не пуста 
		{
			{
				TLock lockHead(_head->_lockElem); //блокируем голову от возможного обращения с хвоста
				_head->_prev=el; //выставляем ссылку на новую голову у старой
			}
			_head=el;//выставляем новую голову
		}
	}
 
 
 
};
 
 
int main() {
	TQueue<int> q;
	q.push(7);
	q.pop();
	// your code goes here
	return 0;
}

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