【Linux系统编程】条件变量

原创 已于 2024-05-20 14:15:38 修改 · 961 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

于 2024-05-20 14:07:26 首次发布

条件变量

        条件变量，通知状态的改变。条件变量允许一个线程就某个共享变量的状态变化通知其他线程，并让其他线程等待(阻塞于)这一通知。

​        条件变量总是结合互斥量使用。条件变量就共享变量的状态改变发出通知，而互斥量则提供对该共享变量访问的互斥。

演示程序:

​        定义一个变量a，线程1当a为0时对a+1，线程2当a为1时对a-1，循环10次，a的结果应该是0和1交替。

​        两个线程需要不断的轮询结果，造成CPU浪费。可以使用条件变量解决:线程1不满足运行条件时，先休眠等待，其他线程运行到满足线程1的运行条件时，通知并唤醒线程⒉继续执行。

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>
#include<errno.h>
#include<stdlib.h>
#include<time.h>

pthread_rwlock_t mtx;//定义读写锁
int a = 0;

void* thread1(void* arg) {
    for(int i = 0; i < 10; i++) {
        while(1) {
            pthread_mutex_lock(&mtx);
            if(a == 0) {
                a++;
                printf("a = %d\n", a);
                pthread_mutex_unlock(&mtx);
                break;
            }
            pthread_mutex_unlock(&mtx);
        }
    }
}

void* thread2(void* arg) {
    for(int i = 0; i < 10; i++) {
        while(1) {
            pthread_mutex_lock(&mtx);
            if(a == 1) {
                a--;
                printf("a = %d\n", a);
                pthread_mutex_unlock(&mtx);
                break;
            }
            pthread_mutex_unlock(&mtx);
        }
    }
}

int main(int argc, char* argv[])
{
    pthread_mutex_init(&mtx, NULL);

    pthread_t tid1;
    pthread_t tid2;
    pthread_create(&tid1, NULL, thread1, NULL);
    pthread_create(&tid2, NULL, thread2, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

但是会造成CPU浪费，通过条件变量实现通知

条件变量函数

●int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);

        参数attr表示条件变量的属性，默认值传NULL

●int pthread_cond_destroy(pthread_cond_t *cond);

●int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

        阻塞等待一个条件变量，释放持有的互斥锁，这两步是原子操作

        被唤醒时，函数返回，解除阻塞并重新申请获取互斥锁

●int pthread_cond_signal(pthread_cond_t *cond);

        唤醒一个阻塞在条件变量上的线程

●int pthread_cond_broadcast(pthread_cond_t *cond);

        唤醒全部阻塞在条件变量上的线程

● int pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t *mutex,
const struct timespec*abstime);

        限时等待一个条件变量

        参数abstime是一个timespec结构体，以秒和纳秒表示的绝对时间

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>
#include<errno.h>
#include<stdlib.h>
#include<time.h>

pthread_rwlock_t mtx;
pthread_cond_t cond;
int a = 0;

void* thread1(void* arg) {
    for(int i = 0; i < 10; i++) {
        pthread_mutex_lock(&mtx);
        if(a != 0) {
            pthread_cond_wait(&cond, &mtx);//阻塞等待,释放锁,被唤醒时重新抢锁
        }
        a++;
        printf("a = %d\n", a);
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&mtx);
    }
}

void* thread2(void* arg) {
    for(int i = 0; i < 10; i++) {
        pthread_mutex_lock(&mtx);
        if(a != 1) {
            pthread_cond_wait(&cond, &mtx);
        }
        a--;
        printf("a = %d\n", a);
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&mtx);
    }
}

int main(int argc, char* argv[])
{
    pthread_mutex_init(&mtx, NULL);
    pthread_cond_init(&cond, NULL);

    pthread_t tid1;
    pthread_t tid2;
    pthread_create(&tid1, NULL, thread1, NULL);
    pthread_create(&tid2, NULL, thread2, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

从主动通知代替了轮询

虚假唤醒：不该唤醒的时候唤醒了。

pthread_cond_wait外面如果使用if 判断，再增加两个线程，会出现虚假唤醒

1.假设线程1抢到了锁，加1，通知所有线程抢锁

2.线程⒉抢到了锁，等待并释放锁

3.线程3抢到了锁，减1，通知所有线程抢锁

4.线程1抢到了锁，等待并释放锁

5.注意这里，如果线程3抢到了锁，wait结束，线程继续执行，+1,number变成2

6.number出现问题，不是0和1了，原因是wait结束时没有再次判断number的值

pthread_cond_wait外面使用循环判断，防止出现虚假唤醒

所有的if都换成while就解决了

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>
#include<errno.h>
#include<stdlib.h>
#include<time.h>
//同样操作的线程只有一个才没事
pthread_rwlock_t mtx;
pthread_cond_t cond;
int a = 0;

void* thread1(void* arg) {
    for(int i = 0; i < 10; i++) {
        pthread_mutex_lock(&mtx);
        while(a != 0) {
            pthread_cond_wait(&cond, &mtx);//阻塞等待,释放锁,被唤醒时重新抢锁
        }
        a++;
        printf("a = %d\n", a);
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&mtx);
    }
}

void* thread2(void* arg) {
    for(int i = 0; i < 10; i++) {
        pthread_mutex_lock(&mtx);//一个线程加锁，所有线程都阻塞在lock上
        while(a != 1) {
            pthread_cond_wait(&cond, &mtx);
        }
        a--;
        printf("a = %d\n", a);
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&mtx);
    }
}

void* thread3(void* arg) {
    for(int i = 0; i < 10; i++) {
        pthread_mutex_lock(&mtx);
        while(a != 0) {
            pthread_cond_wait(&cond, &mtx);//阻塞等待,释放锁,被唤醒时重新抢锁
        }
        a++;
        printf("a = %d\n", a);
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&mtx);
    }
}

void* thread4(void* arg) {
    for(int i = 0; i < 10; i++) {
        pthread_mutex_lock(&mtx);
        while(a != 1) {
            pthread_cond_wait(&cond, &mtx);
        }
        a--;
        printf("a = %d\n", a);
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&mtx);
    }
}

int main(int argc, char* argv[])
{
    pthread_mutex_init(&mtx, NULL);
    pthread_cond_init(&cond, NULL);

    pthread_t tid1;
    pthread_t tid2;
    pthread_t tid3;
    pthread_t tid4;
    pthread_create(&tid1, NULL, thread1, NULL);
    pthread_create(&tid2, NULL, thread2, NULL);
    pthread_create(&tid3, NULL, thread3, NULL);
    pthread_create(&tid4, NULL, thread4, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);
    pthread_join(tid4, NULL);
    return 0;
}

生产者消费者模型

​        线程同步典型的案例即为生产者消费者模型，而借助条件变量来实现这一模型，是比较常见的一种方法。假定有两个线程，一个模拟生产者行为，一个模拟消费者行为。两个线程同时操作一个共享资源（一般称之为汇聚)，生产者向其中添加产品，消费者从中消费掉产品。

        相较于互斥量而言，条件变量可以减少竞争。如直接使用互斥量，除了生产者、消费者之间要竞争互斥量以外，消费者之间也需要竞争互斥量，但如果汇聚（链表）中没有数据，消费者之间竞争互斥量是无意义的。有了条件变量机制以后，只有生产者完成生产，才会引起消费者之间的竞争。提高了程序效率。

场景:一个线程产生随机数放入链表中，一个线程从链表中取出一个随机数打印

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>
#include<errno.h>
#include<stdlib.h>
#include<time.h>

pthread_mutex_t mtx;
pthread_cond_t cond;
int a = 0;

struct Node {
    int number;
    struct Node* next;
};
struct Node* head;
 
struct Node* append_node(int number) {//添加节点
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    new_node->number = number;
    new_node->next = head;
    head = new_node;
    return head;
}

int pop_head_node() {//移除头结点
    if (head == NULL) {
        return -1;
    }
    struct Node* temp = head;
    int number = temp->number;
    head = head->next;
    free(temp);
    return number;
}

void* producer(void* arg) {
    while(1) {
        pthread_mutex_lock(&mtx);
        append_node(rand() % 500 + 1);//产生随机数放到链表里
        pthread_cond_broadcast(&cond);//加一个唤醒
        pthread_mutex_unlock(&mtx);
        sleep(1);
    }
}

void* customer(void* arg) {
    while(1) {
        pthread_mutex_lock(&mtx);
        while(head == NULL) {
            pthread_cond_wait(&cond, &mtx);
        }
        int number = pop_head_node();//把移除节点的数字拿出来
        printf("number = %d\n", number);
        pthread_mutex_unlock(&mtx);
    }
}

int main(int argc, char* argv[])
{
    pthread_mutex_init(&mtx, NULL);
    pthread_cond_init(&cond, NULL);
 
    srand(time(NULL));
    pthread_t tid1;
    pthread_t tid2;
    pthread_create(&tid1, NULL, producer, NULL);
    pthread_create(&tid2, NULL, customer, NULL);
 
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

Linux下条件变量的用法
2301_76169061的博客
01-05 420
linux下条件变量用法
头歌Linux系统编程之c编程入门
11-20
【头歌Linux系统编程之C编程入门】是一个关于在Linux环境下进行C语言编程学习的教程。这个教程覆盖了从基础的C语言编程到更高级的Linux系统编程技术，旨在帮助初学者逐步掌握在Linux系统中编写C程序的能力。 1. **...
linux条件变量用法
08-01 828
条件变量是线程中的东西,就是等待某一条件的发生,和信号一样  条件变量使我们可以睡眠等待某种条件出现。  条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。  条件变量类型为pthread_cond_t
Linux线程——条件变量（pthread_cond）详解
最新发布
weixin_45720999的博客
07-08 1228
条件变量（Condition Variable）是线程同步的高级机制，它允许线程在特定条件不满足时主动让出CPU，直到其他线程改变条件并发出通知。条件变量总是与互斥锁配合使用，共同解决复杂的线程同步问题。与互斥锁绑定：必须与配合使用，避免竞争条件。线程阻塞与唤醒阻塞等待释放锁并挂起线程，直到被唤醒。唤醒机制：唤醒一个等待线程（由调度策略决定）。：唤醒所有等待线程。虚假唤醒：线程可能被意外唤醒（即使未收到信号），需用while循环检查条件。API功能描述关键参数返回值使用场景初始化条件变量。
[Linux]-条件变量
levi的博客
06-26 2456
之前我们了解过的死锁的一种情况，就是两个线程通过管道互相读取数据的时候，读的线程抢到了互斥锁，但是由于管道的读端带阻塞功能，会使读线程阻塞，造成互斥锁无法解锁，导致写端的线程也阻塞，直接造成了死锁的出现。我们可以通过设置管道读端不阻塞来解决这个问题，但是管道读端如果不阻塞的话，很难读取到数据，那么我们就要使用条件变量来解决这个问题条件变量简单的说，就是休眠当前任务，然后当需要的条件满足的时候，再次唤醒休眠的任务。通常来说，条件变量是和互斥锁一起使用的。
Linux条件变量
weixin_50374599的博客
12-07 1409
Linux条件变量简单练习。
php条件变量,浅谈Linux条件变量的使用
weixin_28688791的博客
04-12 136
Linux线程同步之间存在多种机制，条件变量是一种类似操作系统里提到的生产者-消费者算法的同步机制，允许线程以无竞争的方式等待特定条件的发生。示例伪代码：void* Thread1(void){while(线程运行条件成立){…pthread_mutex_lock(qlock);while(条件成立)pthread_cond_wait(qcond,qlock);或者pthread_cond_wai...
Linux系统编程-(pthread)线程通信(条件变量).pdf
07-25
【Linux系统编程——pthread线程通信(条件变量)】 在多线程编程中，线程间的通信是非常重要的，条件变量（Condition Variables）是POSIX线程（pthread）库提供的一种同步机制，它允许线程在特定条件满足时才能继续...
【Linux系统编程】线程同步机制详解：互斥锁、读写锁、条件变量及信号量的应用与优化了文档的核心内容
06-22
内容概要：本文详细介绍了Linux系统编程中的线程同步机制，涵盖同步的基本概念及其在编程中的具体实现。文章首先解释了同步的概念，即确保多个控制流在操作共享资源时按预定顺序执行，避免数据混乱。接着深入探讨了...
Linux C 多线程编程之互斥锁与条件变量实例详解
07-14
在Linux下, 线程的互斥量数据类型是pthread_mutex_t. 在使用前, 要对它进行初始化: 对于静态分配的互斥量, 可以把它设置为PTHREAD_MUTEX_INITIALIZER, 或者调用pthread_mutex_init. 对于动态分配的互斥量, 在申请...
Linux系统编程与多进程管理详解
11-14
内容概要：本文详细介绍了Linux系统编程的基础知识，包括动态库配置方法、Makefile的使用、多进程管理以及I/O多路复用技术。具体内容涵盖：环境变量的设置和配置、动态库的加载方式、Makefile的基本语法和变量使用、...
浅谈Linux条件变量的使用
09-15
下面小编就为大家带来一篇浅谈Linux条件变量的使用。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Linux-条件变量
bobbymly的博客
03-05 371
    条件变量通常用于线程间的同步，可以挂起线程，知道某些条件满足被唤醒。通常和互斥锁一同使用。        1. 条件变量定义pthread_cond_t cond;2. 条件变量初始化函数int pthread_cond_init(pthread_cond_t *cond,const pthread_condattr_t *attr);    或者可以通过 pthread_cond_t c...
Linux条件变量的使用
qq_40888486的博客
09-13 769
1. 条件变量的原理 条件变量不是锁，但是条件变量可以阻塞线程，一般将条件变量和互斥锁共同使用，其中互斥锁是为了保护一块区域，条件变量则是用于阻塞线程。一般条件变量的工作方式可以概括为2步 （1）条件不满足，阻塞线程。 （2）条件满足时，通知线程开始工作 2.条件变量常用的函数 1.定义条件变量 pthread_cond_t cond; 2.初始化条件变量 pthread_cond_init( pthread_cond_t *restrict cond; const pt...
Linux 条件变量
challenglistic的博客
05-15 1407
条件变量可以看作是一个等待队列，只有当其他线程给等待队列发送信号时，等待队列中位于队首的线程会解除挂起
linux 条件变量的使用
qq_51288870的博客
03-16 296
#include <stdio.h> #include <unistd.h> #include <pthread.h> pthread_mutex_t mutex; pthread_cond_t cv; void *thread(void *arg) { while(1) { pthread_mutex_lock(&mutex); pthread_cond_wait(&cv,&mutex); printf("hell.
Linux 系统编程之条件变量
hjj1618的博客
05-31 830
使用条件变量的原因 使用条件变量的原因 如果没有条件变量，那么我们等待一个条件满足则会是下面这样的模型： 首先加锁进入临界区去查看条件是否满足，不满足则解锁离开临界区，睡眠一段时间再继续循环判断。在这种情况下如果刚离开临界区，条件变为满足，那么线程必须还要等一段时间重新进入临界区才能知道条件满足（如果在这段时间内，条件依旧一直保持满足的话），如果这一小段时间条件又变为不满足，那么这个线程还要继续循环判断。不断地加锁解锁（会影响使用同一把锁的其他线程），还不能第一时间收到条件满足。这种模型既费时又开销大。
linux系统编程 条件变量
m0_59008960的博客
03-25 423
条件变量不是锁。但他可以造成线程阻塞，通常与互斥锁配合使用，给多线程一个会合的场所。 1 /* 2 头文件：#include<pthread.h> 3 4 初始化条件变量： 5 动态初始化： 6 int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr); 7 静态初始化： 8 pthread_cond_t cond = PTHREA
Linux系统编程之条件变量
蜀沐的博客
06-20 286
条件变量 条件变量本身不是锁！但它也可以造成线程阻塞。通常与互斥锁配合使用 主要应用函数： pthread_cond_init函数 pthread_cond_destroy函数 pthread_cond_wait函数 pthread_cond_timedwait函数 pthread_cond_signal函数 pthread_cond_broadcast函数 以上6 个函数的返回值都是：成功返回0， 失败直接返回错误号。 pthread_cond_t类型 结构体类型 用于定义条件变量 ：pth
Linux系统编程条件变量的使用方法
05-13
条件变量是线程之间进行同步以及协作的一种机制，用于阻塞一个线程直到某个条件为真。在Linux系统编程中，条件变量的使用方法如下： 1. 定义条件变量 ```c pthread_cond_t cond = PTHREAD_COND_INITIALIZER; ``` 2. 定义互斥锁 ```c pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; ``` 3. 线程等待条件变量 ```c pthread_mutex_lock(&mutex); while(!condition){ pthread_cond_wait(&cond, &mutex); } pthread_mutex_unlock(&mutex); ``` 4. 线程唤醒条件变量 ```c pthread_mutex_lock(&mutex); condition = true; pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex); ``` 在上述代码中，线程等待条件变量时，会先获取互斥锁，然后判断条件是否满足，若不满足，则调用pthread_cond_wait函数使线程进入阻塞状态并释放互斥锁。当条件满足时，线程会重新获取互斥锁并继续执行。线程唤醒条件变量时，也需先获取互斥锁，然后改变条件状态并调用pthread_cond_signal函数通知等待的线程，最后释放互斥锁。 需要注意的是，使用条件变量时，必须与互斥锁一起使用，以保证线程同步和互斥。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值