【C语言】【unix c】条件变量线程同步

短命女 2022-06-07 08:54 382阅读 0赞 
  1. 什么是条件变量？
  2.         线程a等待某个条件成立，条件成立，线程a才继续向下执行。线程b的执行使条件成立，条件成立之后唤醒线程a，以继续执行。这个条件就是条件变量
  3.         pthread_cond_t 就是条件变量类型
  5.     对类型的封装如下：
  6.         #include <pthread.h>
  8.         pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //条件变量的静态初始化，定义变量可以用
  10.         int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr);
  11.             功能：初始化一个条件变量
  12.             参数：
  13.                 cond：指定要初始化的条件变量（指向结构pthread_cond_t的指针）
  14.                 cond_attr：NULL 默认的（用于设置条件变量是进程内还是进程间的）
  15.             返回值：0 成功
  16.                     非0 错误
  18.        int pthread_cond_signal(pthread_cond_t *cond);
  19.             功能：启动在等待条件变量变为真的一个线程，每次最多可以给一个线程发送
  20.             参数：
  21.                 cond：指定条件变量
  22.             返回值：0 成功
  23.                  非0 错误
  25.        int pthread_cond_broadcast(pthread_cond_t *cond);
  26.             功能：启动所有的等待条件变量为真的线程
  27.             参数：
  28.                 cond：指定条件变量
  29.             返回值：0 成功
  30.                     非0 错误
  32.        int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);  //等待期间不会占用cpu，先解锁，然后进入睡眠状态，等待接受信号
  33.             功能：等待条件变量为真（无条件等待）
  34.             参数：
  35.                 cond：指定等待的条件变量
  36.                 mutex：等待之前需要解开的锁
  37.             返回值：0 成功
  38.                     非0 错误
  40.        int   pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t *mutex, const struct timespec *abstime); //超时等待
  41.             功能：超时等待，超时返回错误（计时等待）
  42.             参数：
  43.                 cond：指定等待的条件变量
  44.                 mutex：等待之前需要解开的锁
  45.                 abstime：指定等待的时间
  46.             返回值：0 成功
  47.                     非0 错误
  49.        int pthread_cond_destroy(pthread_cond_t *cond);
  50.             功能：销毁一个条件变量
  51.             参数：
  52.                 cound：指定要销毁的条件变量
  53.             返回值：0 成功
  54.                     非0 错误
  55.     操作步骤：
  56.         1、解开mutex锁
  57.         2、让线程等待条件变量为真
  58.         3、条件变量为真时加锁
  60.     生产者和消费者（读者和写者）
  61.     链表实现：生产者生产出来对象，放到链表头部，消费者从链表的头部取出消费
  63.     第一个思考：两个线程如何同步访问链表的头部
  64.     第二个思考：如果链表为空，消费者等待生产者生产对象
  65.     第三个思考：生产者线程生产出对象需要通知消费者
  66.         代码见 cond.c
  67.         #include <stdio.h>
  68.         #include <pthread.h>
  69.         #include <stdlib.h>
  70.         #include <time.h>
  72.         typedef struct node{
  73.             int num;
  74.             struct node  *next;
  75.         }node_t;
  77.         typedef node_t *list_t;
  78.         list_t head=NULL;
  79.         pthread_mutex_t mutex=\
  80.                     PTHREAD_MUTEX_INITIALIZER;
  81.         pthread_cond_t cond=\
  82.                 PTHREAD_COND_INITIALIZER;
  84.         //消费者线程
  85.         void *consume(void *arg){
  86.             node_t *tmp;
  87.             while(1){
  88.                 //加锁
  89.                 pthread_mutex_lock(&mutex);//对临界变量加锁
  90.                 if(head==NULL)//如果头部指向空，等待
  91.                     pthread_cond_wait(&cond,&mutex);
  92.                 tmp=head;//将要删除的节点赋值给中间值，然后头指针指向下一个
  93.                 head=head->next;//
  94.                 //解锁
  95.                 pthread_mutex_unlock(&mutex);
  96.                 //消费tmp节点
  97.                 printf("consum:%d\n",tmp->num);
  98.                 free(tmp);
  99.                 tmp=NULL;
  100.                 sleep(rand()%5);
  101.             }
  102.         }
  104.         //生产者线程
  105.         void *product(void *arg){
  106.    //函数的格式void *(*start_routine) (void *)，返回值是指针，参数也是
  107.             node_t *n;
  108.             while(1){
  109.                 //生产一个新的节点
  110.                 n=(node_t *)malloc(sizeof(node_t));
  111.                 n->num=rand()%1000+1;
  112.                 printf("p:%d\n",n->num);
  113.             //加锁
  114.                 pthread_mutex_lock(&mutex);
  115.                 //将新节点放入到链表的头部
  116.                 n->next=head;
  117.                 head=n;
  118.             //解锁
  119.                 pthread_mutex_unlock(&mutex);
  120.                 //通知消费者
  121.                 pthread_cond_signal(&cond);
  122.                 sleep(rand()%5);
  123.             }
  124.         }
  125.         int main(void){
  126.             pthread_t pid,cid;
  127.             //设置随机数的种子
  128.             srand(time(NULL));
  129.             //创建两个线程，用于生产者和消费者
  130.             pthread_create(&pid,NULL,product,NULL);//创建线程后即执行该线程
  131.             pthread_create(&cid,NULL,consume,NULL);//参数含义是（存放ID的缓存区，NULL缺省属性，线程的执行函数，函数的唯一参数）
  132.             //等待线程的汇合
  133.             pthread_join(pid,NULL);
  134.             pthread_join(cid,NULL);
  135.             //销毁mutex锁
  136.             pthread_mutex_destroy(&mutex);
  137.             pthread_cond_destroy(&cond);
  138.             return 0;
  139.         }
  141.         tarena@ubuntu:~/day/day37$ gcc cond.c -lpthread
  142.         tarena@ubuntu:~/day/day37$ a.out 
  143.         p:637
  144.         consum:637
  145.         p:741
  146.         consum:741
  147.         p:243
  148.         consum:243
  149.         p:651
  150.         consum:651
  151.         p:252
  152.         consum:252
  153.         p:244
  154.         p:612
  155.         p:954
  156.         p:627
  157.         p:564
  158.         consum:564
  159.         p:941
  160.         consum:941
  161.         p:347
  162.         consum:347
  163.         p:28
  164.         consum:28
  165.         p:60
  166.         p:174
  167.         consum:174
  168.         p:824
  169.         p:359
  170.         consum:359
  171.         consum:824
  172.         p:671
  173.         p:8
  174.         p:164
  175.         ^C
  176.     分析：链表会将之前没有出来的先压在下面，直到前面的输出完才会将他们输出来

发表评论

表情：
评论列表 （有 0 条评论，382人围观）

还没有评论，来说两句吧...

相关阅读