多线程的那点儿事17（之多线程数据结构）(转)

http://blog.csdn.net/feixiaoxing/article/details/7058393

【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】

    要想编写多线程，那就要使用锁。而在软件编写中，数据结构是少不了的。所以，我们在编写多线程的时候，就需要考虑一下如何在数据结构中插入锁。当然，有些数据结构是没有锁的，所以自然这个锁并不一定是必须的。

    比如说，我们编写一个多线程堆栈，应该怎么做呢，

[cpp] view plaincopy
  1. typedef struct _STACK  
  2. {  
  3.     void* pData;  
  4.     int maxLen;  
  5.     int top;  
  6.     void* hLock;  
  7.       
  8.     STATUS (*push)(struct _STACK* pStack, void* pData, int size);  
  9.     STATUS (*pop)(struct _STACK* pStack, void* pData, int size);     
  10. }STACK;  

    (1) 初始化操作

[cpp] view plaincopy
  1. STACK* get_new_stack(void* pData, int len, void* pLock)  
  2. {  
  3.     STACK* pStack;  
  4.         
  5.     if(NULL == pData || 0 == len)  
  6.         return NULL;  
  7.   
  8.     pStack = (STACK*)malloc(sizeof(STACK));  
  9.     assert(NULL != pStack);  
  10.   
  11.     memset(pStack, 0, sizeof(STACK));  
  12.     pStack->pData  = pData;  
  13.     pStack->maxLen = len;  
  14.       
  15.     if(NULL != pLock)  
  16.         pStack->hLock = pLock;  
  17.   
  18.     return pStack;  
  19. }    

    (2) 添加数据

[cpp] view plaincopy
  1. STATUS push(struct _STACK* pStack, void* pData, int size)  
  2. {  
  3.     assert(NULL != pStack && NULL != pData);  
  4.   
  5.     if(NULL != pStack->hLock)  
  6.         WaitForSingleObject((HANDLE)pStack->hLock, INFINITE);  
  7.   
  8.     if(pStack->top == pStack->maxLen){  
  9.         if(NULL != pStack->hLock)  
  10.             ReleaseMutex((HANDLE)pStack->hLock);  
  11.           
  12.         return ERROR;  
  13.     }  
  14.   
  15.     memmove((char*)pStack->pData + size * pStack->top, (char*)pData, size);  
  16.     pStack->top ++;  
  17.       
  18.     if(NULL != pStack->hLock)  
  19.         ReleaseMutex((HANDLE)pStack->hLock);          
  20.   
  21.     return OK;  
  22. }  

    (3) 对2进行优化，因为判断的条件比较复杂

[cpp] view plaincopy
  1. #define STACK_CHECK_LOCK(hLock) \  
  2. do{\  
  3.     if(hLock)\  
  4.         WaitForSingleObject((HANDLE)hLock, INFINITE);\  
  5. }while(0)  
  6.   
  7. #define STACK_CHECK_UNLOCK(hLock) \  
  8. do{\  
  9.     if(hLock)\  
  10.         ReleaseMutex((HANDLE)hLock);\  
  11. }while(0)  

    所以，2的代码可以修改为，

[cpp] view plaincopy
  1. STATUS push(struct _STACK* pStack, void* pData, int size)  
  2. {  
  3.     assert(NULL != pStack && NULL != pData);  
  4.   
  5.     STACK_CHECK_LOCK(pStack->hLock);  
  6.   
  7.     if(pStack->top == pStack->maxLen){  
  8.         STACK_CHECK_UNLOCK(pStack->hLock);  
  9.         return ERROR;  
  10.     }  
  11.   
  12.     memmove((char*)pStack->pData + size * pStack->top, (char*)pData, size);  
  13.     pStack->top ++;  
  14.       
  15.     STACK_CHECK_UNLOCK(pStack->hLock);        
  16.     return OK;  
  17. }  


总结:
    (1)  一般来说，比较好的数据结构要兼有多线程和没有多线程两种情况
    (2)  如果需要用其他的锁代替mutex，直接换掉就可以，十分方便

posted @ 2012-01-17 09:36  董雨  阅读(254)  评论(0)  编辑  收藏  举报