多线程中的数据结构使用

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

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

[cpp]  view plain copy

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 plain copy

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 plain copy

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 plain copy

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 plain copy

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，直接换掉就可以，十分方便