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

Question

这是Anthony Williams在6.2.3 C ++ Concurrency in Action中引入的细粒度锁定队列。

/*
    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() data_cond.wait() 。 此时它的CPU周期已用完。 thread2开始了。

thread2完成了push函数并执行了data_cond.notify_one() 。 thread1再次开始。

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

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

Answer 1

是的，OP中描述的情况是可能的，并且会导致通知丢失。 在谓词函数中注入一个很好的大时间延迟可以很容易地触发。 这是Coliru的演示 。 注意程序如何完成10秒（ wait_for超时的长度）而不是100毫秒（生产者在队列中插入项目的时间）。 通知丢失。

在条件变量的设计中隐含的假设是条件的状态（谓词的返回值）在关联的互斥锁被锁定时不能改变。 对于此队列实现，情况并非如此，因为push可以在不保留head_mutex情况下更改队列的“空”。

§30.5p3指定wait有三个原子部分：

1. 释放互斥锁，进入等待状态;
2. 解除等待; 和
3. 重新获取锁定。

请注意，这些都没有提到检查谓词，如果有任何传递给wait 。 使用谓词的wait行为在§30.5.1p15中描述：

功效：

  而（！pred（））\n       等待（锁定）; 

请注意，这里不能保证谓词检查和wait是以原子方式执行的。 有一个先决条件是lock被锁定和它相关的调用线程持有互斥。

至于修复容器以避免丢失通知，我会将其更改为单个互斥实现并完成它。 当push和pop最终都采用相同的互斥锁（ tail_mutex ）时，称它为细粒度锁定有点拉伸。

Answer 2

data_cond.wait()每次唤醒都会检查条件。 因此，即使它已经被检查过，也会在data_cond.notify_one()之后再次检查它。 此时，有弹出的数据（因为线程2刚刚完成了推送），所以它返回。 在这里阅读更多。

您应该担心的唯一问题是当您在空队列上调用wait_and_pop然后再从不wait_and_pop推送任何数据时。 此代码没有用于超时等待并返回错误（或抛出异常）的机制。