多线程的无锁队列

    对于编写多线程的朋友来说，队列具有天生的互斥性。在队列里面，一个负责添加数据，一个负责处理数据。谁也不妨碍谁，谁也离不开谁。所以，队列具有天生的并行性。

[cpp]  view plain copy

1. #define MAX_NUMBER 1000L  
2. #define STATUS int  
3. #define OK     0  
4. #define FALSE -1  
5.   
6. typedef struct _QUEUE_DATA  
7. {  
8.     int data[MAX_NUMBER];  
9.     int head;  
10.     int tail;  
11. }QUEUE_DATA;   

    此时，一个线程压入数据，操作为push_data，

[cpp]  view plain copy

1. STATUS push_data(QUEUE_DATA* pQueue, int data)  
2. {  
3.     if(NULL == pQueue)  
4.         return ERROR;  
5.   
6.     if(pQueue->head == ((pQueue->tail) + 1)% MAX_NUMBER)  
7.         return ERROR;  
8.   
9.     pQueue->data[pQueue->tail] = data;  
10.     pQueue->tail = (pQueue->tail + 1)% MAX_NUMBER;  
11.     return OK;  
12. }  

    那么，还有一个线程就负责处理数据pop_data，

[cpp]  view plain copy

1. STATUS pop_data(QUEUE_DATA* pQueue, int* pData)  
2. {  
3.     if(NULL == pQueue || NULL == pData)  
4.         return ERROR;  
5.   
6.     if(pQueue->head == pQueue->tail)  
7.         return ERROR;  
8.   
9.     *pData = pQueue->data[pQueue->head];  
10.     pQueue->head = (pQueue->head + 1)% MAX_NUMBER;  
11.     return OK;  
12. }  

总结：
    （1）队列只适合两个线程并行使用，一个压入数据，一个弹出数据
    （2）队列是没有锁的并行，没有死锁的危险
    （3）队列中head和tail只有在计算结束之前的时候才能进行自增运算