c++的queue在多线程下崩溃原因分析

这是个难找的bug,c++的bug真是防不胜防。若不是单点调试,在生产环境中可真不好找。以下是我排查此bug的一个过程记录,留作备忘,在以后的使用过程中要小心避坑。

问题产生

我们知道c++的queue和map等数据结构是线程并发不安全的,为此我们常封装实现了线程安全的priority_queue,姑且叫做 thread_safe::priority_queue。(关于c++并发编程这块儿推荐经典书籍《C++并发编程实战》)。本以为封装后就可以放心在多线程中使用了,结果崩溃了,且还是偶发的。

先看以下示例:

#include 
#include 
using namespace std;

int main()
{
    cout<<"Hello World"< pqueue;
     //pushing value in pqueue.
    cout<

再看以下示例:

#include 
#include 
using namespace std;

int main()
{
   std::cout<<"Hello World\n";
    pqueue.push(10);
    std::cout<

提出几个问题。这两个示例分别会输出什么?

做下测试会发现,第一个示例直接就崩了,第二个会输出 pqueue is not empty,有点儿跟想象的不一样。可能你回说这样的测试无意义吧,正常使用中,连基本的queue是否是empty都不判断吗?

c++的queue在多线程下崩溃原因分析_第1张图片

这也是本次bug的导火索。请看在多线程中的示例:

thread_safe::priority_queue priorityQueue_;

void task_A() {
    LOGGING_DEBUG(" task_A start...");
    while (true) {
        // 1
        if (priorityQueue_.empty()) {
            LOGGING_WARN("priorityQueue is empty.");
            return;
        }
        // 2
        auto taskPtr = priorityQueue_.top();
        if (taskPtr) {

        } else {
            LOGGING_ERROR("taskPtr is nullptr.");
            priorityQueue_.pop();
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

在多线程环境下, 即便有priorityQueue_.empty()的判断,但是也已经失去了意义。因为并发的情况下,执行到2时,能保证priorityQueue_非空?可能它已经是empty了。

以下是本次测试thread_safe_queue的实现:

namespace thread_safe
{
template >
class queue
{
public:
  explicit queue(const Container &ctnr = Container()) : storage(ctnr) {}
  bool empty() const
  {
    std::lock_guard lock(mutex);
    return storage.empty();
  }

  size_t size() const
  {
    std::lock_guard lock(mutex);
    return storage.size();
  }

  T &back()
  {
    std::lock_guard lock(mutex);
    return storage.back();
  }
  const T &back() const
  {
    std::lock_guard lock(mutex);
    return storage.back();
  }

  T &front()
  {
    std::lock_guard lock(mutex);
    return storage.front();
  }
  const T &front() const
  {
    std::lock_guard lock(mutex);
    return storage.front();
  }

  void push(const T &u)
  {
    std::lock_guard lock(mutex);
    storage.push(u);
  }

  void pop()
  {
    std::lock_guard lock(mutex);
    storage.pop();
  }

private:
  std::queue storage;
  mutable std::mutex mutex;
};

template , class Compare = std::less>
class priority_queue
{
public:
  explicit priority_queue(const Compare &x = Compare(), const Container &y = Container()) : storage(x, y) {}
  template 
  priority_queue(InputIterator first, InputIterator last, const Compare &x = Compare(),
                 const Container &y = Container())
      : storage(first, last, x, y)
  {
  }

  bool empty() const
  {
    std::lock_guard lock(mutex);
    return storage.empty();
  }

  size_t size() const
  {
    std::lock_guard lock(mutex);
    return storage.size();
  }

  //  T &top(void)
  //  {
  //    std::lock_guard lock(mutex);
  //    return storage.top();
  //  }
  const T &top() const
  {
    std::lock_guard lock(mutex);
    return storage.top();
  }

  void push(const T &u)
  {
    std::lock_guard lock(mutex);
    storage.push(u);
  }

  void pop()
  {
    std::lock_guard lock(mutex);
    if (!storage.empty())
      storage.pop();
  }

private:
  std::priority_queue storage;
  mutable std::mutex mutex;
};

}  // namespace thread_safe

可以基于此封装在多线程中测试验证下。 

结论

一定要多做测试,尤其是在多线程的环境下。涉及全局资源的访问要谨慎,必要时要加锁给予保护。不能因为封装实现了thread_safe_queue就认为真的safe了。以上的那个示例,priorityQueue_做了封装,但它也是全局资源的一种,并不能放心的在多线程下使用,该加锁的地方还是得加锁。

此外类似queue的这种使用,要确保在一个原子操作内完成,不可被打断。试想一个线程刚好pop,另外一个线程却刚要执行top会怎样?逻辑就错了。 还有队列为了入队出队的准确性,最好只有一对一的生产和消费,否则结果未必准确。

你可能感兴趣的:(C++,c++,开发语言)