当前位置:   article > 正文

C++ 11 利用std::queue创建安全队列 等待队列

std::queue

头文件:更新了下 添加了一个析构时 调用回调函数 供 用户释放资源  不用使用场景下 销毁资源的方式不一样 所以设置了一个回调函数 这样不用的 场景 将销毁资源的方式交给用户 

真是妙啊 !!!! PopData那个有问题 请使用 wait_and_pop那个 

  1. #pragma once
  2. #include <mutex>
  3. #include <queue>
  4. #include <functional>
  5. #include <future>
  6. #include <thread>
  7. #include <utility>
  8. #include <vector>
  9. #include <condition_variable>
  10. typedef void(*PFEXIT)(void *param);
  11. class SafeQueue
  12. {
  13. private:
  14. std::queue<void *> m_queue; //利用模板函数构造队列
  15. mutable std::mutex m_mutex; // 访问互斥信号量
  16. mutable std::condition_variable data_cond;
  17. int m_max_size = 5;
  18. PFEXIT m_clean = NULL;
  19. public:
  20. SafeQueue() ;
  21. SafeQueue(int size) ;
  22. SafeQueue(SafeQueue &&other);
  23. ~SafeQueue();
  24. bool isEmpty();
  25. int GetSize();
  26. void SetCleanFunction(PFEXIT func);
  27. bool PushData(void *data);
  28. bool PopData(void *data)=delete;
  29. void * wait_and_pop();
  30. };

源文件:

  1. #pragma once
  2. #include <queue>
  3. #include <mutex>
  4. #include <condition_variable>
  5. #include <initializer_list>
  6. #include "safequeue.h"
  7. #include <iostream>
  8. using namespace std;
  9. SafeQueue::SafeQueue()
  10. {
  11. cout<<__FUNCTION__;
  12. }
  13. SafeQueue::SafeQueue(int size)
  14. {
  15. m_max_size = size;
  16. cout<<__FUNCTION__<<endl;
  17. }
  18. SafeQueue::SafeQueue(SafeQueue &&other)
  19. {
  20. }
  21. SafeQueue::~SafeQueue()
  22. {
  23. std::unique_lock<std::mutex> lock(m_mutex);
  24. std::cout<<__FUNCTION__<<"queue size:"<<m_queue.size()<<endl;
  25. while (m_queue.size())
  26. {
  27. auto data = std::move(m_queue.front());
  28. m_queue.pop();
  29. if(m_clean)
  30. {
  31. m_clean(data);
  32. }
  33. }
  34. }
  35. void SafeQueue::SetCleanFunction(PFEXIT func)
  36. {
  37. m_clean = func;
  38. }
  39. bool SafeQueue::isEmpty()
  40. {
  41. std::unique_lock<std::mutex> lock(m_mutex);
  42. return m_queue.empty();
  43. }
  44. bool SafeQueue::PushData(void *data)
  45. {
  46. std::unique_lock<std::mutex> lock(m_mutex);
  47. if(m_queue.size() == m_max_size)
  48. {
  49. return false;
  50. }
  51. m_queue.emplace(data);
  52. data_cond.notify_one();
  53. return true;
  54. }
  55. bool SafeQueue::PopData(void *data)
  56. {
  57. std::unique_lock<std::mutex> lock(m_mutex);
  58. if (m_queue.empty())
  59. return false;
  60. data = std::move(m_queue.front());
  61. m_queue.pop();
  62. return true;
  63. }
  64. int SafeQueue::GetSize()
  65. {
  66. std::unique_lock<std::mutex> lock(m_mutex);
  67. return m_queue.size();
  68. }
  69. void * SafeQueue::wait_and_pop()
  70. {
  71. std::unique_lock<std::mutex> lock(m_mutex);
  72. data_cond.wait(lock,[this]{return !this->m_queue.empty();});
  73. if(m_queue.size() == 0)
  74. {
  75. return NULL;
  76. }
  77. else
  78. {
  79. auto value =std::move(m_queue.front());
  80. m_queue.pop();
  81. return value;
  82. }
  83. }

使用的时候  创建队列之后 指定对应的 回调函数 如下图:

 这样delete 队列的时候就如果队列不为空就会走到这个函数里面 释放对应的资源

本文内容由网友自发贡献,转载请注明出处:【wpsshop博客】
推荐阅读
相关标签
  

闽ICP备14008679号