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

Cand

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

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);

复制代码

(1) 初始化操作

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) 添加数据

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进行优化，因为判断的条件比较复杂

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的代码可以修改为，

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

ㄣ负二代

我来坐沙发。。嘿嘿{:3_226:}