多线程的那点儿事14（之无锁队列）

 

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

[cpp] ​​view plain​​​​copy​​

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

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

[cpp] ​​view plain​​​​copy​​

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

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

[cpp] ​​view plain​​​​copy​​

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

总结：

    （1）队列只适合两个线程并行使用，一个压入数据，一个弹出数据

    （2）队列是没有锁的并行，没有死锁的危险

    （3）队列中head和tail只有在计算结束之前的时候才能进行自增运算