linux下c语言实现多线程通信—环形缓冲区,可用于生产者(producer)/消费者(consumer)-凯发app官方网站

凯发app官方网站-凯发k8官网下载客户端中心 | | 凯发app官方网站-凯发k8官网下载客户端中心

heguangsui123

凯发app官方网站首页　| 　　| 　

随祥

  • 博客访问： 27953
  • 博文数量： 8
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 10
  • 用 户 组： 普通用户
  • 注册时间： 2018-04-16 10:56
个人简介

hello world

文章分类

（8）

  • （0）
  • （0）
  • （0）
  • （3）
  • （5）
  • （0）
文章存档

（3）

（5）

我的朋友
最近访客
推荐博文
相关博文
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
linux下c语言实现多线程通信—环形缓冲区,可用于生产者(producer)/消费者(consumer)

分类： linux

2019-04-24 14:17:53

原文地址： 作者：andyhzw

操作系统：ubuntu10.04

前言：
    在嵌入式开发中，只要是带操作系统的，在其上开发产品应用，基本都需要用到多线程。
    为了提高效率，尽可能的提高并发率。因此，线程之间的通信就是问题的核心。
    根据当前产品需要，使用 环形缓冲区 解决。

一，环形缓冲区的实现
    1，cbuf.h

点击(此处)折叠或打开

  1. #ifndef __cbuf_h__
  2. #define __cbuf_h__

  4. #ifdef __cplusplus
  5. extern "c" {
  6. #endif

  8. /* define to prevent recursive inclusion
  9. -------------------------------------*/
  10. #include "types.h"
  11. #include "thread.h"


  14. typedef    struct _cbuf
  15. {
  16.     int32_t        size;            /* 当前缓冲区中存放的数据的个数 */
  17.     int32_t        next_in;        /* 缓冲区中下一个保存数据的位置 */
  18.     int32_t        next_out;        /* 从缓冲区中取出下一个数据的位置 */
  19.     int32_t        capacity;        /* 这个缓冲区的可保存的数据的总个数 */
  20.     mutex_t        mutex;            /* lock the structure */
  21.     cond_t        not_full;        /* full -> not full condition */
  22.     cond_t        not_empty;        /* empty -> not empty condition */
  23.     void        *data[cbuf_max];/* 缓冲区中保存的数据指针 */
  24. }cbuf_t;


  27. /* 初始化环形缓冲区 */
  28. extern    int32_t        cbuf_init(cbuf_t *c);

  30. /* 销毁环形缓冲区 */
  31. extern    void        cbuf_destroy(cbuf_t    *c);

  33. /* 压入数据 */
  34. extern    int32_t        cbuf_enqueue(cbuf_t *c,void *data);

  36. /* 取出数据 */
  37. extern    void*        cbuf_dequeue(cbuf_t *c);


  40. /* 判断缓冲区是否为满 */
  41. extern    bool        cbuf_full(cbuf_t    *c);

  43. /* 判断缓冲区是否为空 */
  44. extern    bool        cbuf_empty(cbuf_t *c);

  46. /* 获取缓冲区可存放的元素的总个数 */
  47. extern    int32_t        cbuf_capacity(cbuf_t *c);


  50. #ifdef __cplusplus
  51. }
  52. #endif

  54. #endif
  55. /* end of file
  56. ---------------------------------------------------------------*/

    2，cbuf.c

点击(此处)折叠或打开

  1. #include "cbuf.h"



  5. /* 初始化环形缓冲区 */
  6. int32_t        cbuf_init(cbuf_t *c)
  7. {
  8.     int32_t    ret = oper_ok;

  10.     if((ret = mutex_init(&c->mutex)) != oper_ok)    
  11.     {
  12. #ifdef debug_cbuf
  13.     debug("cbuf init fail ! mutex init fail !\n");
  14. #endif
  15.         return ret;
  16.     }

  18.     if((ret = cond_init(&c->not_full)) != oper_ok)    
  19.     {
  20. #ifdef debug_cbuf
  21.     debug("cbuf init fail ! cond not full init fail !\n");
  22. #endif
  23.         mutex_destroy(&c->mutex);
  24.         return ret;
  25.     }

  27.     if((ret = cond_init(&c->not_empty)) != oper_ok)
  28.     {
  29. #ifdef debug_cbuf
  30.     debug("cbuf init fail ! cond not empty init fail !\n");
  31. #endif
  32.         cond_destroy(&c->not_full);
  33.         mutex_destroy(&c->mutex);
  34.         return ret;
  35.     }

  37.     c->size     = 0;
  38.     c->next_in    = 0;
  39.     c->next_out = 0;
  40.     c->capacity    = cbuf_max;

  42. #ifdef debug_cbuf
  43.     debug("cbuf init success !\n");
  44. #endif

  46.     return ret;
  47. }


  50. /* 销毁环形缓冲区 */
  51. void        cbuf_destroy(cbuf_t    *c)
  52. {
  53.     cond_destroy(&c->not_empty);
  54.     cond_destroy(&c->not_full);
  55.     mutex_destroy(&c->mutex);

  57. #ifdef debug_cbuf
  58.     debug("cbuf destroy success \n");
  59. #endif
  60. }



  64. /* 压入数据 */
  65. int32_t        cbuf_enqueue(cbuf_t *c,void *data)
  66. {
  67.     int32_t    ret = oper_ok;

  69.     if((ret = mutex_lock(&c->mutex)) != oper_ok)    return ret;

  71.     /*
  72.      * wait while the buffer is full.
  73.      */
  74.     while(cbuf_full(c))
  75.     {
  76. #ifdef debug_cbuf
  77.     debug("cbuf is full !!!\n");
  78. #endif
  79.         cond_wait(&c->not_full,&c->mutex);
  80.     }

  82.     c->data[c->next_in] = data;
  83.     c->size;
  84.     c->next_in %= c->capacity;

  86.     mutex_unlock(&c->mutex);

  88.     /*
  89.      * let a waiting consumer know there is data.
  90.      */
  91.     cond_signal(&c->not_empty);

  93. #ifdef debug_cbuf
  94. //    debug("cbuf enqueue success ,data : %p\n",data);
  95.     debug("enqueue\n");
  96. #endif

  98.     return ret;
  99. }



  103. /* 取出数据 */
  104. void*        cbuf_dequeue(cbuf_t *c)
  105. {
  106.     void     *data     = null;
  107.     int32_t    ret     = oper_ok;

  109.     if((ret = mutex_lock(&c->mutex)) != oper_ok)    return null;

  111.        /*
  112.      * wait while there is nothing in the buffer
  113.      */
  114.     while(cbuf_empty(c))
  115.     {
  116. #ifdef debug_cbuf
  117.     debug("cbuf is empty!!!\n");
  118. #endif
  119.         cond_wait(&c->not_empty,&c->mutex);
  120.     }

  122.     data = c->data[c->next_out];
  123.     c->size--;
  124.     c->next_out %= c->capacity;

  126.     mutex_unlock(&c->mutex);


  129.     /*
  130.      * let a waiting producer know there is room.
  131.      * 取出了一个元素，又有空间来保存接下来需要存储的元素
  132.      */
  133.     cond_signal(&c->not_full);

  135. #ifdef debug_cbuf
  136. //    debug("cbuf dequeue success ,data : %p\n",data);
  137.     debug("dequeue\n");
  138. #endif

  140.     return data;
  141. }


  144. /* 判断缓冲区是否为满 */
  145. bool        cbuf_full(cbuf_t    *c)
  146. {
  147.     return (c->size == c->capacity);
  148. }

  150. /* 判断缓冲区是否为空 */
  151. bool        cbuf_empty(cbuf_t *c)
  152. {
  153.     return (c->size == 0);
  154. }

  156. /* 获取缓冲区可存放的元素的总个数 */
  157. int32_t        cbuf_capacity(cbuf_t *c)
  158. {
  159.     return c->capacity;
  160. }


二，辅助文件
    为了提高程序的移植性，对线程相关进行封装。
    1，thread.h

点击(此处)折叠或打开

  1. #ifndef __thread_h__
  2. #define __thread_h__

  4. #ifdef __cplusplus
  5. extern "c" {
  6. #endif

  8. /* define to prevent recursive inclusion
  9. -------------------------------------*/
  10. #include "types.h"





  16. typedef    struct _mutex
  17. {
  18.     pthread_mutex_t        mutex;
  19. }mutex_t;


  22. typedef    struct _cond
  23. {
  24.     pthread_cond_t        cond;
  25. }cond_t;


  28. typedef    pthread_t        tid_t;
  29. typedef    pthread_attr_t    attr_t;
  30. typedef    void*    (* thread_fun_t)(void*);


  33. typedef    struct _thread
  34. {
  35.     tid_t            tid;
  36.     cond_t            *cv;
  37.     int32_t            state;
  38.     int32_t            stack_size;
  39.     attr_t         attr;
  40.     thread_fun_t    fun;
  41. }thread_t;



  45. /* mutex */
  46. extern    int32_t        mutex_init(mutex_t    *m);
  47. extern    int32_t        mutex_destroy(mutex_t    *m);
  48. extern    int32_t        mutex_lock(mutex_t    *m);
  49. extern    int32_t        mutex_unlock(mutex_t    *m);


  52. /* cond */
  53. extern    int32_t        cond_init(cond_t    *c);
  54. extern    int32_t        cond_destroy(cond_t    *c);
  55. extern    int32_t        cond_signal(cond_t *c);
  56. extern    int32_t        cond_wait(cond_t    *c,mutex_t *m);



  60. /* thread */
  61. /* 线程的创建，其属性的设置等都封装在里面 */
  62. extern    int32_t        thread_create(thread_t *t);
  63. //extern    int32_t        thread_init(thread_t    *t);

  65. #define    thread_join(t, p)     pthread_join(t, p)
  66. #define    thread_self()        pthread_self()
  67. #define    thread_sigmask        pthread_sigmask


  70. #ifdef __cplusplus
  71. }
  72. #endif

  74. #endif
  75. /* end of file
  76. ---------------------------------------------------------------*/

    2，thread.c

点击(此处)折叠或打开

  1. #include "thread.h"




  6. /* mutex */
  7. int32_t        mutex_init(mutex_t    *m)
  8. {
  9.     int32_t        ret = oper_ok;

  11.     if((ret = pthread_mutex_init(&m->mutex, null)) != 0)
  12.         ret = -thread_mutex_init_error;

  14.     return ret;
  15. }


  18. int32_t        mutex_destroy(mutex_t    *m)
  19. {
  20.     int32_t        ret = oper_ok;

  22.     if((ret = pthread_mutex_destroy(&m->mutex)) != 0)
  23.         ret = -mutex_destroy_error;

  25.     return ret;
  26. }



  30. int32_t        mutex_lock(mutex_t    *m)
  31. {
  32.     int32_t        ret = oper_ok;

  34.     if((ret = pthread_mutex_lock(&m->mutex)) != 0)
  35.         ret = -thread_mutex_lock_error;

  37.     return ret;
  38. }



  42. int32_t        mutex_unlock(mutex_t    *m)
  43. {
  44.     int32_t        ret = oper_ok;

  46.     if((ret = pthread_mutex_unlock(&m->mutex)) != 0)
  47.         ret = -thread_mutex_unlock_error;
  48.     
  49.     return ret;
  50. }






  57. /* cond */
  58. int32_t        cond_init(cond_t    *c)
  59. {
  60.     int32_t        ret = oper_ok;

  62.     if((ret = pthread_cond_init(&c->cond, null)) != 0)
  63.         ret = -thread_cond_init_error;

  65.     return ret;
  66. }



  70. int32_t        cond_destroy(cond_t    *c)
  71. {
  72.     int32_t        ret = oper_ok;

  74.     if((ret = pthread_cond_destroy(&c->cond)) != 0)
  75.         ret = -cond_destroy_error;
  76.     
  77.     return ret;
  78. }



  82. int32_t        cond_signal(cond_t *c)
  83. {
  84.     int32_t        ret = oper_ok;


  87.     if((ret = pthread_cond_signal(&c->cond)) != 0)
  88.         ret = -cond_signal_error;
  89.     
  90.     return ret;
  91. }




  96. int32_t        cond_wait(cond_t    *c,mutex_t *m)
  97. {
  98.     int32_t        ret = oper_ok;

  100.     if((ret = pthread_cond_wait(&c->cond, &m->mutex)) != 0)
  101.         ret = -cond_wait_error;    
  102.     
  103.     return ret;
  104. }


三，测试
    1，测试代码

点击(此处)折叠或打开

  1. /*
  2.  * cbuf begin
  3.  */
  4. #define        over    (-1)

  6. static        cbuf_t    cmd;
  7. static        int        line_1[200];
  8. static        int        line_2[200];
  9. //static        int        temp = 0;

  11. static        bool    line1_finish = false;
  12. static        bool    line2_finish = false;

  14. void*    producer_1(void *data)
  15. {
  16.     int32_t    i = 0;

  18.     for(i = 0; i < 200; i)
  19.     {
  20.         line_1[i] = i1000;
  21.         cbuf_enqueue(&cmd, &line_1[i]);

  23.         if(0 == (i % 9)) sleep(1);
  24.     }

  26.     line1_finish = true;

  28.     return null;
  29. }

  31. void*    producer_2(void *data)
  32. {
  33.     int32_t    i = 0;

  35.     for(i = 0; i < 200; i)
  36.     {
  37.         line_2[i] = i20000;
  38.         cbuf_enqueue(&cmd, &line_2[i]);

  40.         if(0 == (i % 9)) sleep(1);
  41.     }

  43.     line2_finish = true;

  45.     return null;
  46. }


  49. void*    consumer(void *data)
  50. {
  51.     int32_t        *ptr = null;

  53.     while(1)
  54.     {
  55.         ptr = cbuf_dequeue(&cmd);
  56.         printf("%d\n",*ptr);

  58.         if(cbuf_empty(&cmd) && line2_finish && line1_finish)
  59.         {
  60.             printf("quit\n");
  61.             break;
  62.         }
  63.     }

  65.     return null;
  66. }


  69. void    test_cbuf_oper(void)
  70. {
  71.     pthread_t    l_1;
  72.     pthread_t    l_2;
  73.     pthread_t    c;
  74.     
  75.     cbuf_init(&cmd);

  77.     pthread_create(&l_1,null,producer_1,0);
  78.     pthread_create(&l_2,null,producer_2,0);
  79.     pthread_create(&c,null,consumer,0);

  81.     pthread_join(l_1,null);
  82.     pthread_join(l_2,null);
  83.     pthread_join(c,null);

  85.     cbuf_destroy(&cmd);
  86. }


  89. void    test_cbuf(void)
  90. {
  91.     test_cbuf_oper();
  92. }


  95. /*
  96.  * cbuf end
  97.  */

    2，测试结果



四，参考文件
1，《bareos-master》源码
2，《nginx》源码


阅读(1723) | 评论(0) | 转发(0) |
0

上一篇：

下一篇：

给主人留下些什么吧！~~
| | | | |

凯发app官方网站 copyright 2001-2010 chinaunix.net all rights reserved 北京皓辰网域网络信息技术有限公司. 凯发k8官网下载客户端中心的版权所有

感谢所有关心和支持过chinaunix的朋友们
")); function link(t){ var href= $(t).attr('href'); href ="?url=" encodeuricomponent(location.href); $(t).attr('href',href); //setcookie("returnouturl", location.href, 60, "/"); }
网站地图