10.6 Linux_并发_线程条件变量

概述

条件变量的作用：

条件变量和互斥量配合使用，主要应用于生产者和消费者问题。

这种问题也是一种临界资源的问题，但与互斥量一文中 "写文件" 这种资源不同。文件是一直存在的临界资源，而生产者的资源不是一直存在，资源的产生需要一些条件。条件变量实现了在等待生产者时，消费者进入休眠状态，提高运行效率。

条件变量使用方法：

1、初始化互斥量、条件变量

2.1 生产者：加锁互斥量->生产资源->发送信号给条件变量->解锁互斥量

2.2 消费者：加锁互斥量->无资源时等待条件变量->消费资源->解锁互斥量

相关函数

1、初始化

//动态初始化
int pthread_cond_init(pthread_cond_t *restrict cond,
                      const pthread_condattr_t *restrict attr);
//静态初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

返回值：成功返回0，失败返回错误码

cond：要初始化的条件变量

attr：条件变量属性，NULL代表默认属性

2、销毁 

int pthread_cond_destroy(pthread_cond_t *cond);

返回值：成功返回0，失败返回错误码

cond：要销毁的条件变量

3、等待资源

//等待临界资源,阻塞
int pthread_cond_wait(pthread_cond_t *restrict cond,
                      pthread_mutex_t *restrict mutex);
//等待临界资源,一段时间后退出阻塞
int pthread_cond_timedwait(pthread_cond_t *restrict cond,
                           pthread_mutex_t *restrict mutex,
                           const struct timespec *restrict abstime);

cond：等待哪一个条件变量的信号

mutex：与条件变量搭配使用的互斥量

注意：该函数在没有资源时，会解锁互斥量，并把本线程休眠。当接收到资源时，会解除休眠，并再次把互斥量上锁

4、发送信号 

//单个发送信号,代表资源来了,所有线程竞争该资源
int pthread_cond_signal(pthread_cond_t *cond);
//广播发送信号,代表资源来了
int pthread_cond_broadcast(pthread_cond_t *cond);

cond：要向哪一个条件变量发送信号

注意：当 "发送信号" 比 "等待资源" 早时，"等待资源" 是接收不到信号的，这会导致信号丢失。这意味着当运行到 "等待资源" 时，会进入阻塞，直到第二次 "发送信号" 到来

生产者消费者示例代码

#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
pthread_mutex_t mutex;//互斥锁
pthread_cond_t cond;//条件变量
//资源
struct resource{
char num;
struct resource* pNext;
};
struct resource Head;
struct resource* pTail;
//消费者
void* consumer(void* arg){
struct resource* pResource = NULL;
while(1){
//1.加锁互斥量
pthread_mutex_lock(&mutex);
//2.无资源时等待条件变量,有资源时不断消耗资源
while(Head.pNext == NULL){//while的作用:防止信号为广播时产生惊群效应
pthread_cond_wait(&cond,&mutex);
}
//3.消费资源
pResource = Head.pNext;
Head.pNext = Head.pNext->pNext;
if(Head.pNext == NULL){
pTail = &Head;
}
printf("consumer:num = %d\n",pResource->num);
free(pResource);
//4.解锁互斥量
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
//生产者
void* producer(void* arg){
struct resource* pNew = NULL;
int i = 0;
while(1){
//1.加锁互斥量
pthread_mutex_lock(&mutex);
//2.生产资源
if((pNew = malloc(sizeof(struct resource))) == NULL){
printf("malloc err\n");
pthread_exit(NULL);
}
pNew->num = i++;
pNew->pNext = NULL;
pTail->pNext = pNew;
pTail = pNew;
printf("producer:num = %d\n",pNew->num);
//3.发送信号给条件变量
pthread_cond_signal(&cond);
//4.解锁互斥量
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
int main(){

pthread_t tid;
Head.pNext = NULL;
pTail = &Head;
//初始化互斥锁和条件变量
pthread_mutex_init(&mutex,NULL);
pthread_cond_init(&cond,NULL);

//创建线程
if(pthread_create(&tid,NULL,producer,NULL) != 0){
perror("pthread_create");
pthread_detach(tid);
return -1;
}
if(pthread_create(&tid,NULL,consumer,NULL) != 0){
perror("pthread_create");
return -1;
}
while(1);
//销毁互斥锁和条件变量
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
return 0;
}

原文地址：https://blog.csdn.net/Fresh_man111/article/details/142690030

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！