win32 线程同步缓冲队列

用于进程内线程间数据通信/同步

1. //CBufList.h
3. #ifndef _BUF_LIST_h_
4. #define _BUF_LIST_h_
7. #include "CRWLock.h"
8. #include <stdlib.h>
10. enum eBufCellStatus
11. {
12.  eFree = 0,
13.  eAllocated,
14.  eActived,
15. };
17. #define HALFMAX_SORTKEY ((uint32_t)(0xffffffff)>>1)
19. struct TBufCellComHead
20. {
21.  TBufCellComHead *lpPreCell;
22.  TBufCellComHead *lpNextCell;
23.  eBufCellStatus eCellStatus;
24.  uint32_t  ulSortKey;
25.  uint32_t  ulDataSize;
26.  uint8_t   *lpData; 
27. };
29. class CBufList
30. {
31. public:
32.  CBufList();
34.  int32_t Init(uint32_t ulCellSize, uint32_t ulCount, 
35.      uint32_t ulMaxCount, uint32_t ulMaxActiveCount = 0,
36.      BOOL bIsWorkWithEvent = TRUE);
38.  int32_t Destroy(void);
39.  void WorkerExit(void);
41.  TBufCellComHead* AllocateOnListHead(void);
42.  TBufCellComHead* AllocateInsBySortKey(uint32_t ulSortKey);
44.  int32_t Active(TBufCellComHead* lpBufCell);
46.  TBufCellComHead* GetBufCellOnProc(void);
47.  int32_t Release(TBufCellComHead* lpBufCell);
49.  inline BOOL IsEmpty(void) const
50.  {
51.   return (NULL == m_lpListOnProc);
52.  }
54.  inline HANDLE GetActiveHandle(void) const
55.  {
56.   return m_hExistAcvtivedBufCell;
57.  }
59.  inline HANDLE GetExitHandle(void) const
60.  {
61.   return m_hWorkExit;
62.  }
64.  inline uint32_t GetCurActiveCount(void) const
65.  {
66.   return m_ulCurActiveCount;
67.  }
69.  inline void SetMaxActiveCount(uint32_t ulMaxActiveCount)
70.  {
71.   m_ActiveCountLock.WLock();
72.   m_ulMaxActiveCount = ulMaxActiveCount;
73.   m_ActiveCountLock.WUnLock();
74.   if (m_ulCurActiveCount!=0)
75.   {
76.    ::SetEvent(m_hExistAcvtivedBufCell);
77.   }
78.  }
80.  inline uint32_t GetMaxActiveCount(void) const
81.  {
82.   return m_ulMaxActiveCount;
83.  }
85. private:
87.  int32_t InitLeakMem(uint32_t ulCellSize, uint32_t ulCount);
88.  BOOL IsMyCell(TBufCellComHead* lpBufCell);
90. private:
92.  TBufCellComHead *m_list;
93.  TBufCellComHead *m_listAppend;
95.  uint32_t m_ulCellSize;
96.  uint32_t m_ulCurCount;
97.  uint32_t m_ulMaxCount;
99.  uint32_t m_ulCurActiveCount;
100.  uint32_t m_ulMaxActiveCount;
103.  TBufCellComHead *m_lpListHead;
104.  TBufCellComHead *m_lpListOnProc;
105.  TBufCellComHead *m_lpListTail;
107.  BOOL m_bIsWorkWithEvent;
108.  HANDLE m_hExistAcvtivedBufCell;
109.  HANDLE m_hIsWorkExit;
110.  HANDLE m_hWorkExit;
112.  CRWLock m_ListHeadLock;
113.  CRWLock m_ListTailLock;
114.  CRWLock m_ListOnProcLock;
115.  CRWLock m_ActiveCountLock;
117. };
120. #endif
128. //CBufList.cpp
130. #include "CBufList.h"
132. CBufList::CBufList(void)
133. {
134.  m_bIsWorkWithEvent = FALSE;
136.  m_ulCellSize = 0;
137.  m_ulCurCount = 0;
138.  m_ulMaxCount = 0;
140.  m_ulCurActiveCount = 0;
141.  m_ulMaxActiveCount = 0;
143.  m_list = NULL;
144.  m_listAppend = NULL;
146.  m_lpListHead = NULL;
147.  m_lpListTail = NULL;
148.  m_lpListOnProc = NULL;
150.  m_hExistAcvtivedBufCell = NULL;
151.  m_hWorkExit = NULL;
152.  m_hIsWorkExit = NULL;
153. }
155. TBufCellComHead* CBufList::AllocateOnListHead(void)
156. {
157.  TBufCellComHead *pTmp = NULL;
159.  m_ListTailLock.Lock();//Disable alloc
160.  if (m_lpListTail->eCellStatus != eFree)
161.  {
162.   if (m_ulCurCount >= m_ulMaxCount)
163.   {
164.    m_ListTailLock.UnLock();
165.    return NULL;
166.   }
168.   pTmp = (TBufCellComHead *)malloc(m_ulCellSize);
169.   if (NULL == pTmp)
170.   {
171.    m_ListTailLock.UnLock();
172.    return pTmp;
173.   }
174.   if (NULL == m_listAppend)
175.   {
176.    m_listAppend = m_lpListTail;
177.   }
179.   memset(pTmp, 0 , m_ulCellSize);
181.   m_ulCurCount++;
183.   pTmp->lpPreCell = m_lpListTail;
184.   pTmp->lpNextCell = NULL;
185.   if (m_ulCellSize>sizeof(TBufCellComHead))
186.   {
187.    pTmp->lpData = (uint8_t *)pTmp + sizeof(TBufCellComHead);
188.    pTmp->ulDataSize = m_ulCellSize - sizeof(TBufCellComHead);
189.   }
190.   m_lpListTail->lpNextCell = pTmp;
191.   m_lpListTail = pTmp;
192.  }
194.  pTmp = m_lpListTail;
195.  m_lpListTail = m_lpListTail->lpPreCell;
196.  m_lpListTail->lpNextCell = NULL;
198.  pTmp->eCellStatus = eAllocated;
199.  pTmp->lpNextCell = NULL;
200.  pTmp->lpPreCell = NULL;
203.  m_ListHeadLock.Lock();
204.  pTmp->lpNextCell = m_lpListHead;
205.  pTmp->lpPreCell = NULL;
206.  m_lpListHead->lpPreCell = pTmp;
207.  m_lpListHead = pTmp;
208.  m_ListHeadLock.UnLock();
210.  if (NULL == m_lpListOnProc)
211.  {
212.   
213.   m_ListOnProcLock.Lock();
214.   m_lpListOnProc = pTmp;
215.   m_ListOnProcLock.UnLock();
216.  }
218.  m_ListTailLock.UnLock();//Enable alloc
220.  return pTmp;
221. }
223. TBufCellComHead* CBufList::AllocateInsBySortKey(uint32_t ulSortKey)
224. {
225.  TBufCellComHead *pTmp = NULL;
227.  if (0 == m_ulMaxActiveCount)
228.  {
229.   return NULL;
230.  }
232.  m_ListTailLock.Lock();//Disable alloc
233.  if (m_lpListTail->eCellStatus != eFree)
234.  {
235.   if (m_ulCurCount >= m_ulMaxCount)
236.   {
237.    m_ListTailLock.UnLock();
238.    return NULL;
239.   }
240.   
241.   pTmp = (TBufCellComHead *)malloc(m_ulCellSize);
242.   if (NULL == pTmp)
243.   {
244.    m_ListTailLock.UnLock();
245.    return pTmp;
246.   }
247.   if (NULL == m_listAppend)
248.   {
249.    m_listAppend = m_lpListTail;
250.   }
251.   
252.   memset(pTmp, 0 , m_ulCellSize);
253.   
254.   m_ulCurCount++;
255.   
256.   pTmp->lpPreCell = m_lpListTail;
257.   pTmp->lpNextCell = NULL;
258.   if (m_ulCellSize>sizeof(TBufCellComHead))
259.   {
260.    pTmp->lpData = (uint8_t *)pTmp + sizeof(TBufCellComHead);
261.    pTmp->ulDataSize = m_ulCellSize - sizeof(TBufCellComHead);
262.   }
263.   m_lpListTail->lpNextCell = pTmp;
264.   m_lpListTail = pTmp;
265.  }
267.  pTmp = m_lpListTail;
268.  m_lpListTail = m_lpListTail->lpPreCell;
269.  m_lpListTail->lpNextCell = NULL;
271.  pTmp->eCellStatus = eAllocated;
272.  pTmp->ulSortKey = ulSortKey;
273.  pTmp->lpNextCell = NULL;
274.  pTmp->lpPreCell = NULL;
277.  if (((ulSortKey>m_lpListHead->ulSortKey) && (ulSortKey-m_lpListHead->ulSortKey<HALFMAX_SORTKEY))
278.   ||((ulSortKey<m_lpListHead->ulSortKey)&&(m_lpListHead->ulSortKey-ulSortKey>=HALFMAX_SORTKEY)))
279.  {
280.   m_ListHeadLock.Lock();
281.   m_lpListHead->lpPreCell = pTmp;
282.   pTmp->lpNextCell = m_lpListHead;
283.   pTmp->lpPreCell = NULL;
284.   m_lpListHead = pTmp;
285.   m_ListHeadLock.UnLock();
287.   if (NULL == m_lpListOnProc)
288.   {
289.    
290.    m_ListOnProcLock.Lock();
291.    m_lpListOnProc = pTmp;
292.    m_ListOnProcLock.UnLock();
293.   }
295.  }
296.  else
297.  { 
299.   m_ListOnProcLock.Lock();
301.   TBufCellComHead *pTmpSort = m_lpListHead->lpNextCell;
302.   while ((pTmpSort!=NULL) && (pTmpSort->eCellStatus!=eFree))
303.   {
304.    if (((ulSortKey>pTmpSort->ulSortKey) && (ulSortKey-pTmpSort->ulSortKey<HALFMAX_SORTKEY))
305.     ||((ulSortKey<pTmpSort->ulSortKey)&&(pTmpSort->ulSortKey-ulSortKey>=HALFMAX_SORTKEY)))
306.    {  
307.     pTmp->lpNextCell = pTmpSort;
308.     pTmp->lpPreCell = pTmpSort->lpPreCell;
309.     if (pTmpSort->lpPreCell != NULL)
310.     {
311.      pTmpSort->lpPreCell->lpNextCell = pTmp;
312.     }
313.     pTmpSort->lpPreCell = pTmp;
314.     
315.     break;
316.    }
317.    pTmpSort = pTmpSort->lpNextCell;
318.   }
319.   
321.   if ((NULL==pTmp->lpPreCell)&&(NULL==pTmp->lpNextCell))
322.   { 
323.    if (NULL == pTmpSort)
324.    {
325.     pTmpSort = m_lpListTail;
326.    }
327.    else
328.    {
329.     pTmpSort = pTmpSort->lpPreCell;
330.    }
332.    pTmp->lpNextCell = pTmpSort->lpNextCell;
333.    pTmp->lpPreCell = pTmpSort;
334.    if (pTmpSort->lpNextCell != NULL)
335.    {
336.     pTmpSort->lpNextCell->lpPreCell = pTmp;
337.    }
338.    pTmpSort->lpNextCell = pTmp;
340.    if (pTmpSort == m_lpListOnProc)
341.    {
342.     m_lpListOnProc = pTmp;
343.    }    
344.    if (pTmpSort == m_lpListTail)
345.    {
346.     m_lpListTail = pTmp;
347.    }
349.   }
351.   m_ListOnProcLock.UnLock();
352.  }
355.  m_ListTailLock.UnLock();//Enable alloc
357.  return pTmp;
358. }
361. int32_t CBufList::Active(TBufCellComHead* lpBufCell)
362. {
363.  if (!IsMyCell(lpBufCell))
364.  {
365.   if (lpBufCell != NULL)
366.   {  
367.    OutputDebugString("CBufList::Active error/n");
368.   }
369.   return -1;
370.  }
373.  if (m_ulMaxActiveCount != 0)
374.  {
375.   m_ActiveCountLock.WLock();
376.   lpBufCell->eCellStatus = eActived;
377.   m_ulCurActiveCount++;
378.   m_ActiveCountLock.WUnLock();
379.  }
380.  else
381.  {
382.   lpBufCell->eCellStatus = eActived;
383.  }
385.  if (m_bIsWorkWithEvent)
386.  {
387.   if (m_ulMaxActiveCount != 0)
388.   {
389.    m_ActiveCountLock.RLock();
390.    if (m_ulCurActiveCount>=m_ulMaxActiveCount)
391.    {
392.     ::SetEvent(m_hExistAcvtivedBufCell);
393.    }
394.    m_ActiveCountLock.RUnLock();
395.   }
396.   
397.   else
398.   {
399.    ::SetEvent(m_hExistAcvtivedBufCell);
400.   }
401.  }
404.  return 0;
405. }
407. TBufCellComHead* CBufList::GetBufCellOnProc(void)
408. {
409.  if (NULL == m_lpListOnProc)
410.  {
411.   return NULL;
412.  }
414.  m_ActiveCountLock.RLock();
415.  if ((m_ulMaxActiveCount>0) && (m_ulMaxActiveCount>m_ulCurActiveCount))
416.  {
417.   m_ActiveCountLock.RUnLock();
418.   return NULL;
419.  }
422.  m_ActiveCountLock.RUnLock();
424.  m_ListOnProcLock.Lock();
425.  if (m_lpListOnProc->eCellStatus != eActived)
426.  {
427.   m_ListOnProcLock.UnLock();
428.   return NULL;
429.  }
431.  return m_lpListOnProc;
432. }
434. BOOL CBufList::IsMyCell(TBufCellComHead* lpBufCell)
435. {
436.  TBufCellComHead *pTmp;
438.  pTmp = m_lpListHead;
439.  while (pTmp != NULL)
440.  {
441.   if (pTmp == lpBufCell)
442.   {
443.    return TRUE;
444.   }
445.   pTmp = pTmp->lpNextCell;
446.  } 
448.  return FALSE;
450. }
452. int32_t CBufList::Release(TBufCellComHead* lpBufCell)
453. {
454.  if (!IsMyCell(lpBufCell))
455.  {
456.   if (lpBufCell != NULL)
457.   {
458.    OutputDebugString("CBufList::Release error/n");
459.   }
460.   return -1;
461.  }
463.  if (m_ulMaxActiveCount != 0)
464.  {
465.   m_ActiveCountLock.WLock();
466.   m_ulCurActiveCount--;
467.   m_lpListOnProc->eCellStatus = eFree;
468.   m_lpListOnProc->ulSortKey = 0;
469.   m_ActiveCountLock.WUnLock();
470.  }
471.  else
472.  {
473.   m_lpListOnProc->eCellStatus = eFree;
474.  }
476.  m_lpListOnProc = m_lpListOnProc->lpPreCell;
478.  m_ListOnProcLock.UnLock();
482.  if (m_bIsWorkWithEvent && (m_lpListOnProc!=NULL))
483.  {
484.   if (m_ulMaxActiveCount>0)
485.   {
486.    m_ActiveCountLock.RLock();
487.    if (m_ulMaxActiveCount<=m_ulCurActiveCount)
488.    {
489.     ::SetEvent(m_hExistAcvtivedBufCell);
490.    }
491.    m_ActiveCountLock.RUnLock();
492.   }
493.   else
494.   {
495.    ::SetEvent(m_hExistAcvtivedBufCell);
496.   }
497.  }
498.  return 0;
499. }
502. int32_t CBufList::Init(uint32_t ulCellSize, uint32_t ulCount, 
503.        uint32_t ulMaxCount, uint32_t ulMaxActiveCount,
504.      BOOL bIsWorkWithEvent)
505. {
506.  uint32_t ulTotalSize = ulCellSize * ulCount;
507.  TBufCellComHead *pTmp;
509.  m_ulMaxCount = ulMaxCount;
511.  m_ActiveCountLock.WLock();
512.  m_ulMaxActiveCount = ulMaxActiveCount;
513.  m_ActiveCountLock.WUnLock();
515.  if (ulCount>ulMaxCount)
516.  {
517.   return -1;
518.  }
520.  if (bIsWorkWithEvent)
521.  {
522.   m_hExistAcvtivedBufCell = CreateEvent(NULL, FALSE, FALSE, NULL);
523.   if (NULL == m_hExistAcvtivedBufCell)
524.   {
525.    return -1;
526.   }
527.   
528.   m_hWorkExit = CreateEvent(NULL, FALSE, FALSE, NULL);
529.   if (NULL == m_hWorkExit)
530.   {
531.    CloseHandle(m_hExistAcvtivedBufCell);
532.    return -1;
533.   }
535.   m_hIsWorkExit = CreateEvent(NULL, TRUE, FALSE, NULL);
536.   if (NULL == m_hIsWorkExit)
537.   {
538.    CloseHandle(m_hExistAcvtivedBufCell);
539.    CloseHandle(m_hWorkExit);
540.    return -1;
541.   }
542.  }
544.  m_list = (TBufCellComHead *)malloc(ulTotalSize);
546.  if (NULL == m_list)
547.  {
548.   return InitLeakMem(ulCellSize, ulCount);
549.  }
550.  else
551.  {
552.   memset(m_list, 0 , ulTotalSize);
553.  }
556.  m_bIsWorkWithEvent = bIsWorkWithEvent;
557.  m_ulCellSize = ulCellSize;
558.  m_ulCurCount = ulCount;
559.  m_lpListHead = m_list;
560.  m_lpListTail = (TBufCellComHead *)((uint8_t *)m_list + (ulTotalSize - ulCellSize));
561.  m_listAppend = m_lpListTail;
563.  m_lpListHead->lpPreCell = NULL;
564.  pTmp = m_lpListHead;
566.  while (pTmp != m_lpListTail)
567.  {
568.   pTmp->lpNextCell = (TBufCellComHead *)((uint8_t *)pTmp + ulCellSize);
569.   pTmp->lpNextCell->lpPreCell = pTmp;
570.   if (ulCellSize>sizeof(TBufCellComHead))
571.   {
572.    pTmp->lpData = (uint8_t *)pTmp + sizeof(TBufCellComHead);
573.    pTmp->ulDataSize = ulCellSize - sizeof(TBufCellComHead);
574.   }
576.   pTmp = pTmp->lpNextCell;
577.  }
579.  if (ulCellSize>sizeof(TBufCellComHead))
580.  {
581.   pTmp->lpData = (uint8_t *)pTmp + sizeof(TBufCellComHead);
582.   pTmp->ulDataSize = ulCellSize - sizeof(TBufCellComHead);
583.  }
584.  pTmp->lpNextCell = NULL;
586.  return 0;
587. }
589. int32_t CBufList::InitLeakMem(uint32_t ulCellSize, uint32_t ulCount)
590. {
591.  return -1;
592. }
594. int32_t CBufList::Destroy(void)
595. {
596.  TBufCellComHead *pTmp,*pToDel;
598.  if (m_bIsWorkWithEvent)
599.  {
600.   uint32_t ret;
601.   
602.   while (1)
603.   {
604.    ::SetEvent(m_hWorkExit);
605.    
606.    ret = WaitForSingleObject(m_hIsWorkExit, INFINITE);
607.    if (ret != WAIT_TIMEOUT)
608.    {
609.     break;
610.    }
612.   }
613.   
614.   CloseHandle(m_hIsWorkExit);
615.   CloseHandle(m_hWorkExit);  
616.   CloseHandle(m_hExistAcvtivedBufCell);
617.  }
621.  if (m_list != NULL)
622.  {
623.   if (m_listAppend!=NULL)
624.   {
625.    pTmp = m_lpListHead;
626.    while (pTmp != NULL)
627.    {
628.     pToDel = pTmp;
629.     pTmp = pTmp->lpNextCell; 
630.     if ((pToDel>m_listAppend) || (pToDel<m_list))
631.     {
633.      if (pToDel->lpNextCell != NULL)
634.      {
635.       pToDel->lpNextCell->lpPreCell = pToDel->lpPreCell;
636.      }
637.      
638.      if (pToDel->lpPreCell != NULL)
639.      {
640.       pToDel->lpPreCell->lpNextCell = pToDel->lpNextCell;
641.      }
642.      free(pToDel);
643.     }
644.    }
645.    m_listAppend = NULL;
646.   }
648.   free(m_list);
649.   m_list = NULL;
650.   m_lpListHead = NULL;
651.   m_lpListTail = NULL;
652.   m_lpListOnProc = NULL;
653.  }
658.  return 0;
659. }
661. void CBufList::WorkerExit(void)
662. {
663.  if (m_bIsWorkWithEvent)
664.  {
665.   ::SetEvent(m_hIsWorkExit);
666.  }
667. }