基于c++11同步队列

同步队列

介绍

实现过程

• 变量定义
• 成员函数
• 完整实现
• 例程

介绍

1.本篇文章旨在通过c++11新特新实现基本的参数模板化同步队列，此队列用以支持基本生产者、消费者应用
2.主要通过原子变量、条件变量、互斥锁、链表容器等实现
3.逐步实现此同步队列，并支持基本的生产者、消费者例程

实现过程

变量定义

// 引用使用到的标准库头文件
#include <atomic>              // c++11标准提供原子操作相关，可保证多线程数据访问的安全
#include <condition_variable>  // 条件变量，可用于实现多线程之间的同步操作
#include <list>                // 双向列表队列
#include <mutex>               // c++11标准提供的互斥锁，可用于多线程间数据访问保护操作

template <typename T>    // 参数类型模板化
class SyncQueue          // 同步队列类
{
    ...                  // 省略其它实现
private:
  std::condition_variable m_cv;  // 同步原语
  std::list<T> m_queue;          // 数据队列
  std::mutex m_mutex;            // 互斥锁，保护数据队列多线程访问
  std::atomic_bool m_stop;       // 停止队列，拒绝接收数据
};

成员函数

// 主要提供以下类成员函数
// SyncQueue、~SyncQueue、Push、Take、Stop、Size、IsEmpty等

SyncQueue() : m_stop(false) {}            // 构造函数
  virtual ~SyncQueue() { Stop(true); }    // 析构函数

  void Push(const T &v) {      // 添加数据到类内部数据队列
    if (m_stop)                // 停止添加数据
      return;

    {                          // 减小锁的粒度
      std::lock_guard<std::mutex> locker(m_mutex);   // 保护数据
      m_queue.emplace_back(v);                       // 添加数据
    }
    m_cv.notify_one();    // 通知任意一个其它同步阻塞的线程，有数据可读
  }
  void Push(T &&v) {      // 添加数据到类内部数据队列，形参以右值引用方式传输
    if (m_stop)
      return;

    {
      std::lock_guard<std::mutex> locker(m_mutex);
      m_queue.emplace_back(v);
    }
    m_cv.notify_one();
  }

  void Take(std::list<T> *ret) {     // 获取类内部队列数据，一次获取所有
    if (ret == nullptr)              // 判断是否空指针
        return;

    {
      std::unique_lock<std::mutex> locker(m_mutex);

      // 同步阻塞当前线程，当通知后唤醒线程，继续执行之后的流程，若lambda函数返回 false，则继续阻塞当前线程
      m_cv.wait(locker, [this] { return m_stop || !m_queue.empty(); });   
    }

    if (m_stop)
      return;

    std::lock_guard<std::mutex> locker(m_mutex);
    ret->swap(m_queue);    // 获取所有数据
  }
  void Take(T *ret) {      // 获取某一个数据
    if (ret == nullptr)
        return;

    {
      std::unique_lock<std::mutex> locker(m_mutex);
      m_cv.wait(locker, [this] { return m_stop || !m_queue.empty(); });
    }

    if (m_stop)
      return;

    std::lock_guard<std::mutex> locker(m_mutex);
    *ret = m_queue.front();           // 获取第一个数据
    m_queue.erase(m_queue.begin());   // 删除已获取的数据
  }

  bool Stop(bool stop) {   // 停止队列
    m_stop.store(stop);
    if (m_stop)
      m_cv.notify_all();   // 唤醒所有同步等待线程
  }
  int Size() {             // 获取队列数据数量
    std::lock_guard<std::mutex> locker(m_mutex);
    return m_queue.size();
  }
  bool IsEmpty() {         // 判断队列是否为空
    std::lock_guard<std::mutex> locker(m_mutex);
    return m_queue.empty();
  }

完整实现

// SyncQueue.hpp

#ifndef SYNCQUEUE_H
#define SYNCQUEUE_H

#include <atomic>
#include <condition_variable>
#include <list>
#include <mutex>

namespace que {

template <typename T> class SyncQueue {
public:
  SyncQueue() : m_stop(false) {}
  virtual ~SyncQueue() { Stop(true); }

  void Push(const T &v) {
    if (m_stop)
      return;

    {
      std::lock_guard<std::mutex> locker(m_mutex);
      m_queue.emplace_back(v);
    }
    m_cv.notify_one();
  }
  void Push(T &&v) {
    if (m_stop)
      return;

    {
      std::lock_guard<std::mutex> locker(m_mutex);
      m_queue.emplace_back(v);
    }
    m_cv.notify_one();
  }
  void Take(std::list<T> *ret) {
    if (ret == nullptr)
      return;

    {
      std::unique_lock<std::mutex> locker(m_mutex);
      m_cv.wait(locker, [this] { return m_stop || !m_queue.empty(); });
    }

    if (m_stop)
      return;

    std::lock_guard<std::mutex> locker(m_mutex);
    ret->swap(m_queue);
  }
  void Take(T *ret) {
    if (ret == nullptr)
      return;

    {
      std::unique_lock<std::mutex> locker(m_mutex);
      m_cv.wait(locker, [this] { return m_stop || !m_queue.empty(); });
    }

    if (m_stop)
      return;

    std::lock_guard<std::mutex> locker(m_mutex);
    *ret = m_queue.front();
    m_queue.erase(m_queue.begin());
  }

  bool Stop(bool stop) {
    m_stop.store(stop);
    if (m_stop)
      m_cv.notify_all();
  }
  int Size() {
    std::lock_guard<std::mutex> locker(m_mutex);
    return m_queue.size();
  }
  bool IsEmpty() {
    std::lock_guard<std::mutex> locker(m_mutex);
    return m_queue.empty();
  }

private:
  std::condition_variable m_cv;
  std::list<T> m_queue;
  std::mutex m_mutex;
  std::atomic_bool m_stop;
};

} // namespace que

#endif // SYNCQUEUE_H

}

例程

• 生产者、消费者模式，数据同步

#include "SyncQueue.hpp"
#include <thread>
#include <chrono>
#include <iostream>

void TestSyncQueue() {
  que::SyncQueue<int> sync;
  std::thread t1([&sync] {
    thread_local int i = 0;
    while (true) {
      sync.Push(std::move(i++));
      std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
  });

  std::thread t2([&sync] {
    int val = -1;
    while (true) {
      sync.Take(&val);
      std::cout << val << " - " << std::this_thread::get_id() << std::endl;
      std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
  });

  std::thread t3([&sync] {
    int val = -1;
    while (true) {
      sync.Take(&val);
      std::cout << val << " - " << std::this_thread::get_id() << std::endl;
      std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
  });

  std::thread t4([&sync] {
    int val = -1;
    while (true) {
      sync.Take(&val);
      std::cout << val << " - " << std::this_thread::get_id() << std::endl;
      std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
  });

  t1.join();
  t2.join();
  t3.join();
  t4.join();
}

int main(int argc, char *argv[]) {
  TestSyncQueue();
  return 0;
}

输出结果：

0 - 139746321880640

1 - 139746330273344

2 - 139746313487936

3 - 139746321880640

4 - 139746330273344

5 - 139746330273344

6 - 139746321880640

7 - 139746321880640

8 - 139746330273344

9 - 139746313487936

10 - 139746321880640

• 异步任务模式

#include "SyncQueue.hpp"
#include <functional>
...

using Task = std::function<void()>;   // 函数包装器，抽象任务类型
class ExecuteTask final {
public:
  ...

  void Push(const Task &task) {
    m_queue.Push(task);
  }
  void Push(Task &&task) {
    m_queue.Push(task);
  }

private:
  que::SyncQueue<Task> m_queue;

  // std::thread* m_thread;   // 此处使用线程或线程池，同步等待任务，异步执行
};

起始