三种数据队列的实现

   
   

    
    



     
     

      
      
  1 /**
  2 * 文件名称：dataqueue.h
  3 * 摘    要：本文件实现了三种数据队列：简单队列，单队列类和双数据队列类。
  4             1) 简单队列：使用List库，动态分配内存，使用临界区保证互斥
  5             2）单队列：采用链表实现，一次性分配内存。减少频繁内存申请开销，同样采用临界区保存互斥。
  6             3）双队列：包含两个单队列，采用ping-pong双缓冲策略，使得在多线程应用中，能保证最小的数据交换开销
  7 * 当前版本：1.0
  8 * 作    者：darkhorse
  9 * 完成日期：2014-6-24
 10 **/
 11 
 12 #ifndef __IMPLIMENT_DATA_QUEUE_H__
 13 #define __IMPLIMENT_DATA_QUEUE_H__
 14 
 15 #include <Windows.h>
 16 #include <iostream>
 17 #include <cstdio>
 18 #include <cstdlib>
 19 #include <assert.h>
 20 #include <list>
 21 namespace hw {
 22 
 23     /*!< 队列满时再次分配数据的元素大小*/
 24     #define ONCE_MALLOC_SIZE    10
 25 
 26     typedef enum Result {
 27         NONE,
 28         MEM_ALLOC_FAILED,
 29         MEM_NOT_ENOUGH,
 30         DATA_NOT_EXISTED,
 31 
 32     };
 33 
 34 
 35     /******************************************************************/
 36     template<typename T>
 37     class CSimpleQueue
 38     {
 39     public:
 40         CSimpleQueue()
 41         {
 42             InitializeCriticalSection(&m_crit);
 43         }
 44         ~CSimpleQueue()
 45         {
 46             DeleteCriticalSection(&m_crit);
 47         }
 48 
 49         void pushData(const T &data)
 50         {
 51             EnterCriticalSection(&m_crit);
 52             m_dataList.push_back(data);
 53             LeaveCriticalSection(&m_crit);
 54         }
 55 
 56         BOOL popData(T &data)
 57         {
 58             EnterCriticalSection(&m_crit);
 59             if (m_dataList.size() > 0)
 60             {
 61                 data = m_dataList.front();
 62                 m_dataList.pop_front();
 63                 LeaveCriticalSection(&m_crit);
 64 
 65                 return TRUE;
 66             }
 67             else
 68             {
 69                 LeaveCriticalSection(&m_crit);
 70                 return FALSE;
 71             }
 72         }
 73 
 74     private:
 75         std::list<T> m_dataList;
 76         CRITICAL_SECTION m_crit;
 77     };
 78 
 79 
 80     /*!< 链表元素*/
 81     template<typename T>
 82     struct DataElement
 83     {
 84         T *m_pData;
 85         DataElement *m_pNext;
 86 
 87         DataElement()
 88         {
 89             reset();
 90         }
 91 
 92         void reset()
 93         {
 94             m_pData = NULL;
 95             m_pNext = NULL;
 96         }
 97     };
 98 
 99     /*********************** 单队列类*******************************/
100     template <typename T>
101     class CSingleQueue
102     {
103     public:
104         CSingleQueue(unsigned int nSize = ONCE_MALLOC_SIZE);
105         ~CSingleQueue();
106 
107         void reset();
108         BOOL pushData(const T &data);
109         BOOL popData(const T* &pData);
110         void removeHead();    /*!< 删除一条数据*/
111         unsigned int getLen();
112         BOOL isEmpty();
113 
114     private:
115         BOOL reAlloc();
116         DataElement<T> *m_pHeadPos; /*!< 队列数据头*/
117         DataElement<T> *m_pTailPos; /*!< 队列数据尾*/
118         DataElement<T> *m_pFreePos; /*!< 空闲数据起始位置*/
119 
120         unsigned int m_nMaxSize; /*!< 队列包含的最大数据大小*/
121         unsigned int m_nCurSize; /*!< 队列当前包含的数据元素大小*/
122         T *m_pDataMem; /*!< 指向分配的数据*/
123     };
124 
125     /*!< 类实现*/
126     template<typename T>
127     CSingleQueue<T>::CSingleQueue(unsigned int nSize)
128     {
129         m_pDataMem = new T[nSize];
130         if(NULL == m_pDataMem)
131         {
132             assert(FALSE);
133         }
134         m_nMaxSize = nSize;
135         m_nCurSize = 0;
136         m_pHeadPos = NULL;
137         m_pFreePos = NULL;
138         m_pTailPos = NULL;
139     }
140 
141     template<typename T>
142     CSingleQueue<T>::~CSingleQueue()
143     {
144         reset();
145         while(m_pFreePos != NULL)
146         {
147             DataElement<T> *pTemp = m_pFreePos;
148             m_pFreePos = m_pFreePos->m_pNext;
149             delete pTemp;
150             pTemp = NULL;
151         }
152         m_nCurSize = 0;
153 
154         if(m_pDataMem != NULL)
155         {
156             delete []m_pDataMem;
157             m_pDataMem = NULL;
158         }
159         m_nMaxSize = 0;
160     }
161 
162     /*!< 重置队列*/
163     template<typename T>
164     void CSingleQueue<T>::reset()
165     {
166         while (m_pHeadPos != NULL)
167         {
168             DataElement<T> *pTemp = m_pHeadPos;
169             m_pHeadPos = m_pHeadPos->m_pNext;
170             pTemp->reset();
171             pTemp->m_pNext = m_pFreePos;
172             m_pFreePos = pTemp;
173         }
174         m_nCurSize = 0;
175         m_pTailPos = NULL;
176     }
177 
178     template<typename T>
179     BOOL CSingleQueue<T>::reAlloc()
180     {
181         for (unsigned int i=0; i<ONCE_MALLOC_SIZE; i++)
182         {
183             DataElement<T> *pTemp = new DataElement<T>;
184             if(NULL == pTemp)
185             {
186                 assert(FALSE);
187                 return FALSE;
188             }
189             pTemp->reset();
190             pTemp->m_pNext = m_pFreePos;
191             m_pFreePos = pTemp;
192         }
193         return TRUE;
194     }
195 
196     template<typename T>
197     BOOL CSingleQueue<T>::pushData(const T &data)
198     {
199         if(m_nCurSize >= m_nMaxSize)
200         {
201             return FALSE;
202         }
203 
204         DataElement<T> *pTemp = NULL;
205         if(m_pFreePos != NULL)
206         {
207             pTemp = m_pFreePos;/*!< 找到第一个空闲结点*/
208             m_pFreePos = m_pFreePos->m_pNext;
209         }
210         else
211         {
212             /*!< 如果没有空闲结点，再次分配*/
213             if (reAlloc())
214             {
215                 if(m_pFreePos != NULL)
216                 {
217                     pTemp = m_pFreePos;/*!< 找到第一个空闲结点*/
218                     m_pFreePos = m_pFreePos->m_pNext;
219                 }
220             }
221         }
222         if(pTemp != NULL)
223         {
224             m_pDataMem[m_nCurSize] = data;/*!< 先将数据拷贝到队列内存*/
225             pTemp->reset();
226             pTemp->m_pData = &m_pDataMem[m_nCurSize];/*!< 给数据成员赋值*/
227 
228             if(NULL == m_pHeadPos)
229             {
230                 m_pHeadPos = pTemp;
231             }
232             else
233             {
234                 m_pTailPos->m_pNext = pTemp;
235             }
236             m_pTailPos = pTemp;
237 
238             m_nCurSize++;
239             return TRUE;
240         }
241         return FALSE;
242     }
243 
244     template<typename T>
245     BOOL CSingleQueue<T>::popData(const T* &pData)
246     {
247         DataElement<T> *pTemp = m_pHeadPos;
248         if(pTemp != NULL)
249         {
250             pData = pTemp->m_pData;
251             return TRUE;
252         }
253         return FALSE;
254     }
255 
256     template<typename T>
257     void CSingleQueue<T>::removeHead()
258     {
259         if (m_pHeadPos != NULL)
260         {
261             DataElement<T> *pTemp = m_pHeadPos;
262             m_pHeadPos = m_pHeadPos->m_pNext;
263             pTemp->reset();
264             pTemp->m_pNext = m_pFreePos;
265             m_pFreePos = pTemp;
266             m_nCurSize--;
267         }
268     }
269 
270     template<typename T>
271     unsigned int CSingleQueue<T>::getLen()
272     {
273         return m_nCurSize;
274     }
275 
276     template<typename T>
277     BOOL CSingleQueue<T>::isEmpty()
278     {
279         return (m_pHeadPos == 0) ? TRUE : FALSE;
280     }
281 
282 
283     /****************************双队列类***************************/
284     template<typename T>
285     class CDoubleQueue
286     {
287     public:
288         CDoubleQueue();
289         ~CDoubleQueue();
290 
291         BOOL init(unsigned int nSize);
292         void release();
293 
294         BOOL pushData(const T &data);
295         BOOL popData(const T* &pData);
296         void removeHead();
297     private:
298         CSingleQueue<T> *m_pPushList;
299         CSingleQueue<T> *m_pPopList;
300         CRITICAL_SECTION m_crit;
301     };
302 
303     /*!< 类的实现*/
304     template<typename T>
305     CDoubleQueue<T>::CDoubleQueue()
306     {
307         m_pPushList = NULL;
308         m_pPopList = NULL;
309         InitializeCriticalSection(&m_crit);
310     }
311 
312     template<typename T>
313     CDoubleQueue<T>::~CDoubleQueue()
314     {
315         DeleteCriticalSection(&m_crit);
316     }
317 
318     template<typename T>
319     void CDoubleQueue<T>::release()
320     {
321         if(m_pPushList != NULL)
322         {
323             delete m_pPushList;
324             m_pPushList = NULL;
325         }
326 
327         if(m_pPopList != NULL)
328         {
329             delete m_pPopList;
330             m_pPopList = NULL;
331         }
332     }
333 
334     template<typename T>
335     BOOL CDoubleQueue<T>::init(unsigned int nSize)
336     {
337         if(nSize == 0)
338         {
339             return FALSE;
340         }
341 
342         release();
343         m_pPushList = new CSingleQueue<T>(nSize);
344         if(NULL == m_pPushList)
345         {
346             return FALSE;
347         }
348 
349         m_pPopList = new CSingleQueue<T>(nSize);
350         if(NULL == m_pPopList)
351         {
352             return FALSE;
353         }
354 
355         return TRUE;
356     }
357 
358     template <class T>
359     BOOL CDoubleQueue<T>::pushData(const T &data)
360     {
361         BOOL bSuccess = FALSE;
362         EnterCriticalSection(&m_crit);
363         bSuccess = m_pPushList->pushData(data);
364         LeaveCriticalSection(&m_crit);
365         return bSuccess;
366     }
367 
368     template <class T>
369     BOOL CDoubleQueue<T>::popData(const T* &pData)
370     {
371         BOOL bCouldRead = TRUE;
372         if(m_pPopList->isEmpty())
373         {
374             EnterCriticalSection(&m_crit);
375             if(m_pPushList->isEmpty())
376             {
377                 LeaveCriticalSection(&m_crit);
378                 bCouldRead = FALSE;
379             }
380             else
381             {
382                 m_pPopList->reset();
383                 CSingleQueue<T> *pTemp = m_pPopList;
384                 m_pPopList = m_pPushList;
385                 m_pPushList = pTemp;
386                 LeaveCriticalSection(&m_crit);
387                 bCouldRead = TRUE;
388             }
389         }
390         if (bCouldRead)
391         {
392             return m_pPopList->popData(pData);
393         }
394         else
395         {
396             return FALSE;
397         }
398     }
399 
400     template <class T>
401     void CDoubleQueue<T>::removeHead()
402     {
403         m_pPopList->removeHead();
404     }
405 }
406 #endif
     
     
 
     
     

      
      
  1 #include "dataqueue.h"
  2 #include <process.h>
  3 #include <assert.h>
  4 
  5 using namespace hw;
  6 using namespace std;
  7 
  8 enum queueType {SIMPLEQ, SINGLEQ, DOUBLEQ, QUIT};
  9 
 10 #define QUEUE_SIZE_TEST 50
 11 CSimpleQueue<int> g_simpleQ;
 12 CSingleQueue<int> g_singleQ(QUEUE_SIZE_TEST);
 13 CDoubleQueue<int> g_doubleQ;
 14 
 15 int gWriteCnt_simple = 0;
 16 int gReadCnt_simple = 0;
 17 
 18 int gWriteCnt_single = 0;
 19 int gReadCnt_single = 0;
 20 
 21 int gWriteCnt_double = 0;
 22 int gReadCnt_double = 0;
 23 
 24 bool gReadThreadQuit = false;
 25 bool gWriteThreadQuit = false;
 26 
 27 void read(void *arg)
 28 {
 29     queueType type = (queueType)(*((queueType*)arg));
 30 
 31     while(!gReadThreadQuit)
 32     {
 33         if(type == SIMPLEQ)
 34         {
 35             int data = 0;
 36             g_simpleQ.popData(data);
 37             gReadCnt_simple++;
 38         }
 39         else if(type == SINGLEQ)
 40         {
 41             const int *pData = NULL;
 42             g_singleQ.popData(pData);
 43             g_singleQ.removeHead();
 44             gReadCnt_single++;
 45         }
 46         else if(type == DOUBLEQ)
 47         {
 48             const int *pData = NULL;
 49             g_doubleQ.popData(pData);
 50             g_doubleQ.removeHead();
 51             gReadCnt_double++;
 52         }
 53         else
 54         {
 55             assert(false);
 56             break;
 57         }
 58         Sleep(10);
 59     }
 60     _endthread();
 61 }
 62 
 63 void write(void *arg)
 64 {
 65     queueType type = (queueType)(*((queueType*)arg));
 66 
 67     while(!gWriteThreadQuit)
 68     {
 69         if(type == SIMPLEQ)
 70         {
 71             int data = 0;
 72             g_simpleQ.pushData(data);
 73             gWriteCnt_simple++;
 74         }
 75         else if(type == SINGLEQ)
 76         {
 77             const int data = 0;
 78             g_singleQ.pushData(data);
 79             gWriteCnt_single++;
 80         }
 81         else if(type == DOUBLEQ)
 82         {
 83             const int data = 0;
 84             g_doubleQ.pushData(data);
 85             gWriteCnt_double++;
 86         }
 87         else
 88         {
 89             assert(false);
 90             break;
 91         }
 92         Sleep(10);
 93     }
 94     _endthread();
 95 }
 96 
 97 void printUsage()
 98 {
 99     printf("usage:test.exe [option]\n \
100     option: \
101     0 use simple queue for test\n \
102     1 use single queue for test\n \
103     2 use double queue for test\n \
104     3 quit\n\n");
105 }
106 int main(int argc, char *argv[])
107 {
108     printUsage();
109 
110     while(1)
111     {
112         int opt;
113         printf("please input the option number: ");
114         scanf_s("%1d", &opt);
115         if(opt == (int)SIMPLEQ)
116         {
117 
118         }
119         else if(opt == (int)SINGLEQ)
120         {
121 
122         }
123         else if(opt == (int)DOUBLEQ)
124         {
125             g_doubleQ.init(QUEUE_SIZE_TEST);
126         }
127         else if(opt == (int)QUIT)
128         {
129             break;
130         }
131         else
132         {
133             printf("invalid number\n");
134             continue;
135         }
136 
137         LARGE_INTEGER freq;
138         LARGE_INTEGER startCount, endCount;
139         QueryPerformanceFrequency(&freq);
140         QueryPerformanceCounter(&startCount);
141 
142         HANDLE readHandle = (HANDLE)_beginthread(write, 0, &opt);
143         HANDLE writeHandle = (HANDLE)_beginthread(read, 0, &opt);
144 
145         LONGLONG sec = 0;
146         /*!< run one second*/
147         while((sec -1000) < 0.00001)
148         {
149             QueryPerformanceCounter(&endCount);
150             sec = (endCount.QuadPart - startCount.QuadPart) * 1000 / freq.QuadPart;        
151         }
152 
153         gReadThreadQuit = true;
154         gWriteThreadQuit = true;
155 
156         WaitForSingleObject(readHandle, INFINITE);
157         WaitForSingleObject(writeHandle, INFINITE);
158 
159         gReadThreadQuit = false;
160         gWriteThreadQuit = false;
161 
162         int readCnt = 0;
163         int writeCnt = 0;
164         if ((queueType)opt == SIMPLEQ)
165         {
166             readCnt = gReadCnt_simple;
167             writeCnt = gWriteCnt_simple;
168         }
169         else if((queueType)opt == SINGLEQ)
170         {
171             readCnt = gReadCnt_single;
172             writeCnt = gWriteCnt_single;
173         }
174         else if((queueType)opt == DOUBLEQ)
175         {
176             readCnt = gReadCnt_double;
177             writeCnt = gWriteCnt_double;
178         }
179         printf("write count： %d, read count： %d\n", writeCnt, readCnt);
180     }
181     return 0;
182 }
     
     
 
 
参考：https://software.intel.com/zh-cn/blogs/2013/03/21/twoqueues/?utm_campaign=CSDN&utm_source=intel.csdn.net&utm_medium=Link&utm_content=%20Multicore%20%e2%80%93%20TwoQueues