用信号量实现的线程安全队列。
简单有用的示例程序，
比起互斥量的实现在多线程时效率更好。

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__

  10. #define QUE_SIZE 8

  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;

  21. extern sem_t queue_sem; 

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

  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>

  16. #include "cir_queue.h"

  18. void* thread_queue(void *arg);

  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;

  34.   init_cir_queue(&cq);

  36.   push_cir_queue(&cq, 1);
  37.   push_cir_queue(&cq, 2);
  38.   push_cir_queue(&cq, 3);

  40.   print_queue(&cq);

  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.   }

  49.   e = pop_cir_queue(&cq);    
  50.   e = pop_cir_queue(&cq);    
  51.   print_queue(&cq);

  53.   push_cir_queue(&cq, 9);
  54.   push_cir_queue(&cq, 100);

  56.   print_queue(&cq);

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


  67.   push_cir_queue(&cq, 20);
  68.   print_queue(&cq);

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

  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.   }

  87.   destroy_cir_queue(&cq);

  89.   printf("Thread joined, it returned %s\n", (char*)thread_result); 
  90.   exit(EXIT_SUCCESS);
  91. }


  94. void *thread_queue(void *cirqueue)
  95. {
  96.   int flag;
  97.   DataType element;

  99.   print_queue((cir_queue_t*)cirqueue);

  101.   flag = is_empty_cir_queue((cir_queue_t*)cirqueue);

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

  108.   push_cir_queue((cir_queue_t*)cirqueue, 5);
  109.   print_queue((cir_queue_t*)cirqueue);

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

  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>

  12. #include "cir_queue.h"

  14. sem_t queue_sem;
  15. /*
  16.  * \Func
  17.  *
  18.  */
  19. void init_cir_queue(cir_queue_t *q)
  20. {    
  21.   int res;

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

  32.   q->front = q->rear = 0;
  33.   q->count = 0;
  34. }

  36. /*
  37.  * \Func
  38.  *
  39.  */
  40. int is_empty_cir_queue(cir_queue_t *q)
  41. {
  42.   int empty_flag;

  44.   sem_wait(&queue_sem);    

  46.   empty_flag = q->front == q->rear;

  48.   sem_post(&queue_sem);

  50.   return empty_flag;
  51. }

  53. /*
  54.  * \Func
  55.  *
  56.  */
  57. int is_full_cir_queue(cir_queue_t *q)
  58. {
  59.   int full_flag;

  61.   sem_wait(&queue_sem);    

  63.   full_flag = q->rear == QUE_SIZE - 1 + q->front;

  65.   sem_post(&queue_sem);

  67.   return full_flag;
  68. }

  70. /*
  71.  * \Func
  72.  *
  73.  */
  74. void push_cir_queue(cir_queue_t *q, DataType x)
  75. {

  77.   if (is_full_cir_queue(q))
  78.   {
  79.     printf("queue overflow.\n");
  80.     return ;
  81.   }

  83.   sem_wait(&queue_sem);    

  85.   q->count++;
  86.   q->data[q->rear] = x;
  87.   q->rear = (q->rear+1) % QUE_SIZE;

  89.   sem_post(&queue_sem);
  90.     
  91. }

  93. /*
  94.  * \Func
  95.  *
  96.  */
  97. DataType pop_cir_queue(cir_queue_t *q)
  98. {
  99.   DataType temp;

  101.   if (is_empty_cir_queue(q))
  102.   {
  103.     printf("queue empty.\n");
  104.     return 0;
  105.   }

  107.   sem_wait(&queue_sem);    

  109.   temp = q->data[q->front];
  110.   q->data[q->front] = 0;
  111.   q->count--;
  112.   q->front = (q->front+1) % QUE_SIZE;

  114.   sem_post(&queue_sem);

  116.   return temp;
  117. }

  119. /*
  120.  * \Func
  121.  *
  122.  */
  123. DataType top_cir_queue(cir_queue_t *q)
  124. {
  125.   DataType x; 

  127.   if (is_empty_cir_queue(q))
  128.   {
  129.     printf("queue is empty.\n");
  130.     return 0;
  131.   }

  133.   sem_wait(&queue_sem);    

  135.   x = q->data[q->front];

  137.   sem_post(&queue_sem);

  139.   return x;
  140. }

  142. void destroy_cir_queue(cir_queue_t *q)
  143. { 
  144.   sem_destroy(&queue_sem);

  146.   return;    
  147. }

  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.   }

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

  166.   sem_post(&queue_sem);

  168.   return;
  169. }

makefile
  1. OBJECTS = main.o cir_queue.o
  2. CC = gcc
  3. CFLAGS = -D_REENTRANT -lpthread -g -Wall


  6. thrd_safe_queue: $(OBJECTS)
  7.   $(CC) $(CFLAGS) -o thrd_safe_queue $(OBJECTS)

  9. main.o: cir_queue.h
  10. cir_queue.o: cir_queue.h


  13. .PHONY:clean
  14. clean:
  15.   rm thrd_safe_queue $(OBJECTS)
# linux
Logo
Linux

更多推荐

网卡速率和双工模式的配置

http://linux.chinaitlab.com/system/792187.html1、mii-tool 配置网络设备协商方式的工具；    1.1 mii-tool 介绍；    mii-tool - view, manipulate media-independent interface status （mii-tool 是查看，管理介质的网络接口的状态）

avatar Linux

Linux虚拟文件系统之文件系统卸载（sys_umount())

Linux中卸载文件系统由umount系统调用实现，入口函数为sys_umount()。较于文件系统的安装较为简单，下面是具体的实现。1. /*sys_umont系统调用*/2. SYSCALL_DEFINE2(umount, char __user *, name, int, flags)3. {4.struct path path;

avatar Linux

Linux系统下超级终端Minicom的使用方法（例如：连接交换机，路由器等）转http://baike.baidu.com/view/2911642.htm?fr=ala0_1

<br />　　Linux系统下超级终端Minicom的使用方法 <br />　　Linux下的Minicom的功能与下的超级终端功能相似，适于在通过超级终端对设备的管理以及对嵌入操作系统的升级，现写出Minicom的使用手册： <br />　　1． 启动minicom <br />　　以root权限登录系统 <br />　　使用命令 <br />　　minicom –s 则minicom启动，屏

avatar Linux