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

#include <thread>
#include <mutex>
using namespace  std;
 
template <typename T>
struct LockableNode
{
   T data;
   LockableNode<T>* next;
 
   // for std::lock_guard & std::lock
   void lock()  { m_.lock();   }
   void unlock(){ m_.unlock(); }
 
   LockableNode(T data=T(),LockableNode<T>* next=0)
       :data(data),next(next)
   { }
 
   private:
    mutex m_;
};
 
template <typename T>
class Queue
{
   public:
      Queue();
      ~Queue();
 
      void push(T e);
      bool pop(T& e);
      //T popAndWait();
 
      void clear();
 
   private:
      void unsynchronizedClear();
 
      typedef LockableNode<T> NodeType;
      typedef std::lock_guard<NodeType> NodeGuard;
      typedef NodeType* NodePtr;
 
      NodePtr fictiveHead_;
      NodePtr fictiveTail_;
};
 
template <typename T>
Queue<T>::Queue()
   :fictiveHead_(new LockableNode<T>()),
    fictiveTail_(new LockableNode<T>())
{}
 
 
template <typename T>
void Queue<T>::unsynchronizedClear()
{
  for(NodePtr ptr= fictiveHead_->next;
      ptr;
      fictiveHead_->next= ptr->next)
  {
    delete ptr;
  }
  fictiveHead_->next= fictiveTail_->next= 0;
}
 
template <typename T>
void Queue<T>::clear()
{
  lock(*fictiveHead_,*fictiveTail_);
  unsynchronizedClear();
}
 
 
template <typename T>
Queue<T>::~Queue()
{
  unsynchronizedClear();
  delete fictiveHead_;
  delete fictiveTail_;
}
 
 
template <typename T>
void Queue<T>::push(T e)
{  
  NodePtr newNode=  new LockableNode<T>(e);
  NodeGuard tailGuard(*fictiveTail_);
 
  if(fictiveTail_->next) // has real Node
  {
    NodeGuard lastGuard(*fictiveTail_->next);
    NodePtr   last=  fictiveTail_->next;
    last->next =     fictiveTail_->next = newNode;
  }
  else  // if empty
  {
    NodeGuard headGuard(*fictiveHead_);
    fictiveHead_->next = fictiveTail_->next = newNode;
  }
}
 
template <typename T>
bool Queue<T>::pop(T& e)
{
  NodeGuard headGuard(*fictiveHead_);
  if(fictiveHead_->next)
  {
    NodeGuard firstGuard(*(fictiveHead_->next));
    NodePtr   first= fictiveHead_->next;
 
    if(first->next)
    {
      fictiveHead_->next = first->next;
    }
    else // one real Node
    {
      NodeGuard tailGuard(*fictiveTail_);
      fictiveHead_->next= fictiveTail_->next= 0; // queue will be empty
    }
 
    e= first->data;
    delete first;
    return true;
 }
  else
      return false;
}
 
 
//template <typename T>
//T Queue<T>::popAndWait()
//{
 
//}
 
 
void fillQ(Queue<string>& sq)
{
   for(int i=0; i<50 ; ++i)
   {
      this_thread::sleep_for(chrono::milliseconds(rand()%500));
      sq.push(to_string(i));
   }
}
//-------------------------------------------------------------------------
 
int main()
{
  srand(time(0));
  {
    Queue<string> sq;
    thread th(&fillQ,ref(sq));
 
    for(;;)
    {
      string s;
      if(sq.pop(s))
        cout<< s <<endl;
      else
      {
        cout<< "-" <<endl;
        this_thread::sleep_for(chrono::milliseconds(rand()%500));
      }
    }
 
    th.join();
  }
    cout<<"done!"<<endl;
    return 0;
}