C++ 中的细粒度锁定队列

这是 Anthony Williams 在第 6.2.3 章中引入的细粒度锁定队列 C++ 并发在行动中。

/*
    pop only need lock head_mutex and a small section of tail_mutex,push only need
    tail_mutex mutex.maximum container concurrency.
*/
template<typename T> class threadsafe_queue
{
    private:
    struct node
    {
        std::shared_ptr<T> data;
        std::unique_ptr<node> next;
    }
    std::mutex head_mutex;   //when change the head lock it.
    std::unique_ptr<node> head;  
    std::mutex tail_mutex;   //when change the tail lock it.
    node* tail;
    std::condition_variable data_cond;
    node* get_tail()
    {
        std::lock_guard<std::mutex> tail_lock(tail_mutex);
        return tail;
    }
    public:
    /* 
        create a dummy node
    */
    threadsafe_queue():
        head(new node),tail(head.get())
    {}
    std::shared_ptr<T> wait_and_pop()
    {
        std::unique_lock<std::mutex> head_lock;
        data_cond.wait(head_lock,[&]{return head.get()!=get_tail();}); //#1
        std::unique_ptr<node> old_head=std::move(head);
        head=std::move(old_head->next);
        return old_head;
    }
    void push(T new_value)
    {
        std::shared_ptr<T> new_data(
        std::make_shared<T>(std::move(new_value)));
        std::unique_ptr<node> p(new node);
        {
            std::lock_guard<std::mutex> tail_lock(tail_mutex);
            tail->data=new_data;
            node* const new_tail=p.get();
            tail->next=std::move(p);
            tail=new_tail;
        }
        data_cond.notify_one();
    }
}

情况是这样的：有两个线程(thread1 和 thread2 (。 thread1正在做wait_and_pop，thread2正在做push。队列为空。

thread1在#2中，在data_cond.wait()之前已经检查过head.get()!=get_tail()。此时它的 CPU 周期已经用完了。 thread2开始了。

thread2完成了push功能并做了data_cond.notify_one()。 thread1又开始了。

现在thread1开始data_cond.wait()，但它永远等待。

这种情况可能发生吗？如果是这样，如何修复此容器？