linux多线程编程(C)：信号量实现的线程安全队列

用信号量实现的线程安全队列。

简单有用的示例程序，

比起互斥量的实现在多线程时效率更好。

cir_queue.h

1. /*
   
2.  * \File
   
3.  * cir_queue.h
   
4.  * \Brief
   
5.  * circular queue
   
6.  */
   
7. #ifndef __CIR_QUEUE_H__
   
8. #define __CIR_QUEUE_H__
   
9. 
   
10. #define QUE_SIZE 8
    
11. 
    
12. typedef int DataType;
    
13. typedef struct cir_queue_t
    
14. {
    
15.   DataType data[QUE_SIZE];
    
16.   int front;
    
17.   int rear;
    
18.   int count;
    
19. }cir_queue_t;
    
20. 
    
21. extern sem_t queue_sem; 
    
22. 
    
23. void init_cir_queue(cir_queue_t* q);
    
24. int is_empty_cir_queue(cir_queue_t* q);
    
25. int is_full_cir_queue(cir_queue_t* q);
    
26. void push_cir_queue(cir_queue_t* q, DataType x);
    
27. DataType pop_cir_queue(cir_queue_t* q);
    
28. DataType top_cir_queue(cir_queue_t* q);
    
29. void destroy_cir_queue(cir_queue_t* q);
    
30. void print_queue(cir_queue_t* q);
    
31. 
    
32. #endif

main.c

1. /*
   
2.  * \File
   
3.  * main.c
   
4.  * \Breif
   
5.  * Thread-safe circular-queue implemented by semaphore
   
6.  * \Author
   
7.  * Hank.yan
   
8.  */
   
9. #include <stdio.h>
   
10. #include <stdlib.h>
    
11. #include <unistd.h>
    
12. #include <string.h>
    
13. #include <pthread.h>
    
14. #include <semaphore.h>
    
15. 
    
16. #include "cir_queue.h"
    
17. 
    
18. void* thread_queue(void *arg);
    
19. 
    
20.     
    
21. /*
    
22.  * \Func
    
23.  * main
    
24.  */
    
25. int main(int argc, char* argv[])
    
26. {
    
27.   int res;
    
28.   cir_queue_t cq;
    
29.   DataType e;
    
30.  
    
31.   pthread_t a_thread, b_thread;
    
32.   void* thread_result;
    
33. 
    
34.   init_cir_queue(&cq);
    
35. 
    
36.   push_cir_queue(&cq, 1);
    
37.   push_cir_queue(&cq, 2);
    
38.   push_cir_queue(&cq, 3);
    
39. 
    
40.   print_queue(&cq);
    
41. 
    
42.   res = pthread_create(&a_thread, NULL, thread_queue, (void*)&cq);
    
43.   if (res != 0)
    
44.   {
    
45.     perror("Thread creation failed.");
    
46.     exit(EXIT_FAILURE);
    
47.   }
    
48. 
    
49.   e = pop_cir_queue(&cq);    
    
50.   e = pop_cir_queue(&cq);    
    
51.   print_queue(&cq);
    
52. 
    
53.   push_cir_queue(&cq, 9);
    
54.   push_cir_queue(&cq, 100);
    
55. 
    
56.   print_queue(&cq);
    
57. 
    
58.   res = pthread_create(&b_thread, NULL, thread_queue, (void*)&cq);
    
59.   if (res != 0)
    
60.   {
    
61.     perror("Thread creation failed.");
    
62.     exit(EXIT_FAILURE);
    
63.   }
    
64.   e = pop_cir_queue(&cq);    
    
65. 
    
66. 
    
67.   push_cir_queue(&cq, 20);
    
68.   print_queue(&cq);
    
69. 
    
70.   printf("Waiting for thread to finish...\n");
    
71.   res = pthread_join(a_thread, &thread_result);
    
72.   if (res != 0)
    
73.   {
    
74.     perror("Thread join failed.");
    
75.     exit(EXIT_FAILURE);
    
76.   }
    
77.   print_queue(&cq);
    
78. 
    
79.   printf("Waiting for thread to finish...\n");
    
80.   res = pthread_join(b_thread, &thread_result);
    
81.   if (res != 0)
    
82.   {
    
83.     perror("Thread join failed.");
    
84.     exit(EXIT_FAILURE);
    
85.   }
    
86. 
    
87.   destroy_cir_queue(&cq);
    
88. 
    
89.   printf("Thread joined, it returned %s\n", (char*)thread_result); 
    
90.   exit(EXIT_SUCCESS);
    
91. }
    
92. 
    
93. 
    
94. void *thread_queue(void *cirqueue)
    
95. {
    
96.   int flag;
    
97.   DataType element;
    
98. 
    
99.   print_queue((cir_queue_t*)cirqueue);
    
100. 
     
101.   flag = is_empty_cir_queue((cir_queue_t*)cirqueue);
     
102. 
     
103.   print_queue((cir_queue_t*)cirqueue);
     
104.   element = pop_cir_queue((cir_queue_t*)cirqueue);
     
105.   element = pop_cir_queue((cir_queue_t*)cirqueue);
     
106.   print_queue((cir_queue_t*)cirqueue);
     
107. 
     
108.   push_cir_queue((cir_queue_t*)cirqueue, 5);
     
109.   print_queue((cir_queue_t*)cirqueue);
     
110. 
     
111.   push_cir_queue((cir_queue_t*)cirqueue, 99);
     
112.   push_cir_queue((cir_queue_t*)cirqueue, 1000);
     
113.   push_cir_queue((cir_queue_t*)cirqueue, 88);
     
114. 
     
115.   print_queue((cir_queue_t*)cirqueue);
     
116.   
     
117.   pthread_exit("Thank you for the cpu time.");
     
118. }

cir_queue.c

1. /*
   
2.  * \File
   
3.  * cir_queue.c
   
4.  */
   
5. #include <stdio.h>
   
6. #include <stdlib.h>
   
7. #include <unistd.h>
   
8. #include <string.h>
   
9. #include <pthread.h>
   
10. #include <semaphore.h>
    
11. 
    
12. #include "cir_queue.h"
    
13. 
    
14. sem_t queue_sem;
    
15. /*
    
16.  * \Func
    
17.  *
    
18.  */
    
19. void init_cir_queue(cir_queue_t *q)
    
20. {    
    
21.   int res;
    
22. 
    
23.   /* Create semaphore */
    
24.   res = sem_init(&queue_sem, 0, QUE_SIZE);
    
25.   if (res != 0)
    
26.   {
    
27.     perror("Semaphore init failed.\n");
    
28.     exit(EXIT_FAILURE);
    
29.   }
    
30.   memset(q->data, 0, QUE_SIZE*sizeof(DataType));
    
31. 
    
32.   q->front = q->rear = 0;
    
33.   q->count = 0;
    
34. }
    
35. 
    
36. /*
    
37.  * \Func
    
38.  *
    
39.  */
    
40. int is_empty_cir_queue(cir_queue_t *q)
    
41. {
    
42.   int empty_flag;
    
43. 
    
44.   sem_wait(&queue_sem);    
    
45. 
    
46.   empty_flag = q->front == q->rear;
    
47. 
    
48.   sem_post(&queue_sem);
    
49. 
    
50.   return empty_flag;
    
51. }
    
52. 
    
53. /*
    
54.  * \Func
    
55.  *
    
56.  */
    
57. int is_full_cir_queue(cir_queue_t *q)
    
58. {
    
59.   int full_flag;
    
60. 
    
61.   sem_wait(&queue_sem);    
    
62. 
    
63.   full_flag = q->rear == QUE_SIZE - 1 + q->front;
    
64. 
    
65.   sem_post(&queue_sem);
    
66. 
    
67.   return full_flag;
    
68. }
    
69. 
    
70. /*
    
71.  * \Func
    
72.  *
    
73.  */
    
74. void push_cir_queue(cir_queue_t *q, DataType x)
    
75. {
    
76. 
    
77.   if (is_full_cir_queue(q))
    
78.   {
    
79.     printf("queue overflow.\n");
    
80.     return ;
    
81.   }
    
82. 
    
83.   sem_wait(&queue_sem);    
    
84. 
    
85.   q->count++;
    
86.   q->data[q->rear] = x;
    
87.   q->rear = (q->rear+1) % QUE_SIZE;
    
88. 
    
89.   sem_post(&queue_sem);
    
90.     
    
91. }
    
92. 
    
93. /*
    
94.  * \Func
    
95.  *
    
96.  */
    
97. DataType pop_cir_queue(cir_queue_t *q)
    
98. {
    
99.   DataType temp;
    
100. 
     
101.   if (is_empty_cir_queue(q))
     
102.   {
     
103.     printf("queue empty.\n");
     
104.     return 0;
     
105.   }
     
106. 
     
107.   sem_wait(&queue_sem);    
     
108. 
     
109.   temp = q->data[q->front];
     
110.   q->data[q->front] = 0;
     
111.   q->count--;
     
112.   q->front = (q->front+1) % QUE_SIZE;
     
113. 
     
114.   sem_post(&queue_sem);
     
115. 
     
116.   return temp;
     
117. }
     
118. 
     
119. /*
     
120.  * \Func
     
121.  *
     
122.  */
     
123. DataType top_cir_queue(cir_queue_t *q)
     
124. {
     
125.   DataType x; 
     
126. 
     
127.   if (is_empty_cir_queue(q))
     
128.   {
     
129.     printf("queue is empty.\n");
     
130.     return 0;
     
131.   }
     
132. 
     
133.   sem_wait(&queue_sem);    
     
134. 
     
135.   x = q->data[q->front];
     
136. 
     
137.   sem_post(&queue_sem);
     
138. 
     
139.   return x;
     
140. }
     
141. 
     
142. void destroy_cir_queue(cir_queue_t *q)
     
143. { 
     
144.   sem_destroy(&queue_sem);
     
145. 
     
146.   return;    
     
147. }
     
148. 
     
149. void print_queue(cir_queue_t* q)
     
150. {
     
151.   int index;
     
152.   if (is_empty_cir_queue(q))
     
153.   {
     
154.     printf("queue is empty.\n");
     
155.     return;
     
156.   }
     
157. 
     
158.   sem_wait(&queue_sem);    
     
159.   printf("QUEUE: ");
     
160.   for (index = 0; index < QUE_SIZE; index++)
     
161.   {
     
162.     printf(" %d ", q->data[index]);
     
163.   }
     
164.   printf("\n");
     
165. 
     
166.   sem_post(&queue_sem);
     
167. 
     
168.   return;
     
169. }

makefile

1. OBJECTS = main.o cir_queue.o
   
2. CC = gcc
   
3. CFLAGS = -D_REENTRANT -lpthread -g -Wall
   
4. 
   
5. 
   
6. thrd_safe_queue: $(OBJECTS)
   
7.   $(CC) $(CFLAGS) -o thrd_safe_queue $(OBJECTS)
   
8. 
   
9. main.o: cir_queue.h
   
10. cir_queue.o: cir_queue.h
    
11. 
    
12. 
    
13. .PHONY:clean
    
14. clean:
    
15.   rm thrd_safe_queue $(OBJECTS)