Linux学习（27）：生产者消费者模型、条件变量、信号量

最新推荐文章于 2024-02-21 19:42:24 发布
最新推荐文章于 2024-02-21 19:42:24 发布
阅读量159 收藏
点赞数
分类专栏： webserver学习第三章 文章标签： 学习 开发语言 linux 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43870645/article/details/129847789
版权

目录

1.生产者消费者模型

2.条件变量

测试代码1：实现生产者--开发者模型

测试代码2：使用条件变量实现生产者消费者模型

3.信号量

测试代码3：使用信号量实现生产者消费者模型

1.生产者消费者模型

生产者消费者模型_kalvin_y_liu的博客-CSDN博客

2.条件变量

条件变量的类型 pthread_cond_t
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t *cond);
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);
    - 等待多长时间，调用了这个函数，线程会阻塞，直到指定的时间结束。
int pthread_cond_signal(pthread_cond_t *cond);
    - 唤醒一个或者多个等待的线程
int pthread_cond_broadcast(pthread_cond_t *cond);
    - 唤醒所有的等待的线程

使用pthread_cond_wait时需要注意：当这个函数调用阻塞的时候，会对互斥锁（第二个参数）进行解锁，当不阻塞时，继续向下执行，会重新加锁。

因此如果在if语句中等待条件时，后面要再加一句解锁操作

不然……他就死锁了

测试代码1：实现生产者--开发者模型

/*
    生产者消费者模型（粗略的版本）
*/
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

// 创建一个互斥量
pthread_mutex_t mutex;

struct Node{
    int num;
    struct Node *next;
    Node(int x): num(x){}
}; 

// 头结点
struct Node * head = NULL;

void * producer(void * arg) {

    // 不断的创建新的节点，添加到链表中
    while(1) {
        pthread_mutex_lock(&mutex);
        struct Node * newNode = (struct Node *)malloc(sizeof(struct Node));
        newNode->next = head;
        head = newNode;
        newNode->num = rand() % 1000;
        printf("add node, num : %d, tid : %ld\n", newNode->num, pthread_self());
        pthread_mutex_unlock(&mutex);
        usleep(100);
    }

    return NULL;
}

void * customer(void * arg) {

    while(1) {
        pthread_mutex_lock(&mutex);
        // 保存头结点的指针
        struct Node * tmp = head;

        // 判断是否有数据
        if(head != NULL) {
            // 有数据
            head = head->next;
            printf("del node, num : %d, tid : %ld\n", tmp->num, pthread_self());
            free(tmp);
            pthread_mutex_unlock(&mutex);
            usleep(100);
        } else {
            // 没有数据
            pthread_mutex_unlock(&mutex);
        }
    }
    return  NULL;
}

int main() {

    pthread_mutex_init(&mutex, NULL);

    // 创建5个生产者线程，和5个消费者线程
    pthread_t ptids[5], ctids[5];

    for(int i = 0; i < 5; i++) {
        pthread_create(&ptids[i], NULL, producer, NULL);
        pthread_create(&ctids[i], NULL, customer, NULL);
    }

    for(int i = 0; i < 5; i++) {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    while(1) {
        sleep(10);
    }

    pthread_mutex_destroy(&mutex);
    //这两行可否交换顺序，在没有while的时候
    pthread_exit(NULL);

    return 0;
}

测试代码2：使用条件变量实现生产者消费者模型

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

// 创建一个互斥量
pthread_mutex_t mutex;
// 创建条件变量
pthread_cond_t cond;

struct Node{
    int num;
    struct Node *next;
};

// 头结点
struct Node * head = NULL;

void * producer(void * arg) {

    // 不断的创建新的节点，添加到链表中
    while(1) {
        pthread_mutex_lock(&mutex);
        struct Node * newNode = (struct Node *)malloc(sizeof(struct Node));
        newNode->next = head;
        head = newNode;
        newNode->num = rand() % 1000;
        printf("add node, num : %d, tid : %ld\n", newNode->num, pthread_self());
        
        // 只要生产了一个，就通知消费者消费
        pthread_cond_signal(&cond);

        pthread_mutex_unlock(&mutex);
        usleep(100);
    }

    return NULL;
}

void * customer(void * arg) {

    while(1) {
        pthread_mutex_lock(&mutex);
        // 保存头结点的指针
        struct Node * tmp = head;
        // 判断是否有数据
        if(head != NULL) {
            // 有数据
            head = head->next;
            printf("del node, num : %d, tid : %ld\n", tmp->num, pthread_self());
            free(tmp);
            pthread_mutex_unlock(&mutex);
            usleep(100);
        } else {
            // 没有数据，需要等待
            // 当这个函数调用阻塞的时候，会对互斥锁进行解锁，当不阻塞的，继续向下执行，会重新加锁。
            //因此如果下面不加一句解锁，即使等待结束也不能都读数据，while循环的第一步就会二次上锁出错
            pthread_cond_wait(&cond, &mutex);
            pthread_mutex_unlock(&mutex);
        }
    }
    return  NULL;
}

int main() {

    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    // 创建5个生产者线程，和5个消费者线程
    pthread_t ptids[5], ctids[5];

    for(int i = 0; i < 5; i++) {
        pthread_create(&ptids[i], NULL, producer, NULL);
        pthread_create(&ctids[i], NULL, customer, NULL);
    }

    for(int i = 0; i < 5; i++) {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    while(1) {
        sleep(10);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    //这三行可否交换顺序
    pthread_exit(NULL);

    return 0;
}

3.信号量

 信号量的类型 sem_t
    int sem_init(sem_t *sem, int pshared, unsigned int value);
        - 初始化信号量
        - 参数：
            - sem : 信号量变量的地址
            - pshared : 0 用在线程间 ，非0 用在进程间
            - value : 信号量中的值

    int sem_destroy(sem_t *sem);
        - 释放资源

    int sem_wait(sem_t *sem);
        - 对信号量加锁，调用一次对信号量的值-1，如果值为0，就阻塞

    int sem_trywait(sem_t *sem);

    int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
    int sem_post(sem_t *sem);
        - 对信号量解锁，调用一次对信号量的值+1

    int sem_getvalue(sem_t *sem, int *sval);

测试代码3：使用信号量实现生产者消费者模型

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>

// 创建一个互斥量
pthread_mutex_t mutex;
// 创建两个信号量
sem_t psem;
sem_t csem;

struct Node{
    int num;
    struct Node *next;
};

// 头结点
struct Node * head = NULL;

void * producer(void * arg) {

    // 不断的创建新的节点，添加到链表中
    while(1) {
        //每调用一次sem_wait，psem-1，减到0阻塞
        sem_wait(&psem);
        pthread_mutex_lock(&mutex);
        struct Node * newNode = (struct Node *)malloc(sizeof(struct Node));
        newNode->next = head;
        head = newNode;
        newNode->num = rand() % 1000;
        printf("add node, num : %d, tid : %ld\n", newNode->num, pthread_self());
        pthread_mutex_unlock(&mutex);
        //对信号量“解锁”，每成功调用一次sem_post，csem+1，消费者就知道可以消费了
        sem_post(&csem);
    }

    return NULL;
}

void * customer(void * arg) {

    while(1) {
        sem_wait(&csem);
        pthread_mutex_lock(&mutex);
        // 保存头结点的指针
        struct Node * tmp = head;
        head = head->next;
        printf("del node, num : %d, tid : %ld\n", tmp->num, pthread_self());
        free(tmp);
        pthread_mutex_unlock(&mutex);
        //解锁一个生产者让他去生产
        sem_post(&psem);
       
    }
    return  NULL;
}

int main() {

    pthread_mutex_init(&mutex, NULL);
    sem_init(&psem, 0, 8);
    sem_init(&csem, 0, 0);

    // 创建5个生产者线程，和5个消费者线程
    pthread_t ptids[5], ctids[5];

    for(int i = 0; i < 5; i++) {
        pthread_create(&ptids[i], NULL, producer, NULL);
        pthread_create(&ctids[i], NULL, customer, NULL);
    }

    for(int i = 0; i < 5; i++) {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    while(1) {
        sleep(10);
    }

    pthread_mutex_destroy(&mutex);

    pthread_exit(NULL);

    return 0;
}

weixin_43870645
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈生产者消费者模型(Linux系统下的两种实现方法)
09-15
总结来说，生产者消费者模型在Linux下的实现主要依赖于同步机制，如信号量和互斥锁，以确保生产者和消费者之间的协同工作，防止资源过度消耗或耗尽。这两种实现方式各有特点，可以根据实际需求选择合适的同步机制。...
（Linux C）利用多进程或多线程模拟实现生产者/消费者问题
02-11
总结，生产者/消费者问题的解决策略主要依赖于同步机制，如信号量、互斥锁和条件变量。在Linux C环境下，多进程和多线程都可以有效地实现这一模型，但它们各有优缺点，选择哪种方式取决于具体的应用场景和性能需求。...
用条件变量来解决生产者消费者问题
chen_mama的专栏
08-11 3257
在上一篇文章中，我使用了匿名信号量什么是条件变量？ 我们可以设想一个场景：线程A需要某个条件成立才能继续执行，否则一直等待下去，而线程B执行过程中使线程的执行条件成立，并且唤醒A。 举个例子，在生产者消费者模型中，消费者如果看到缓冲区为空时，就等待，而生产者往缓冲区添加完数据后，唤醒消费者。 其中这个场景中，可以POSIX的条件变量来实现。 以下是条件变量所需要的函数pth
生产者消费者条件变量模型
oykotxuyang的博客
04-26 122
#include <stdlib.h> #include <unistd.h> #include <pthread.h> struct msg { struct msg *next; int num; }; struct msg *head; pthread_cond_t has_product = PTHREAD_COND_INITIALI...
生产者-消费者 模型 I（条件变量）
weixin_34163553的博客
04-22 108
一、生产者-消费者问题：同步和互斥是进程间很重要的交互模式，而生产者和消费者问题则是同步和互斥的一个经典模型。同步是一种时序关系。如规定了进程1 处理完事情A后，进程2 才能处理事情 B，经典的同步问题是生产者和消费者间的同步。互斥描述的是一种独占关系。如任一时刻，进城1 和进程2 中只能有一个写文件C生产者-消费者问题： 1、在...
条件变量（生产者消费者问题）
qq_43549385的博客
11-16 633
这里我们使用C语言多线程模拟生产者和消费者问题同时采用条件变量的方法解决该问题。当数据栈中没有数据时，消费者阻塞在条件变量上等待生产者通知其消费；而生产者则会不断的向数据栈中写入数据，并且每写入一次都会通知消费者进行消费。
生产者消费者模式及条件变量
个人工作中学到的专业技术与职业发展知识笔记
02-07 590
1、基础概念： 1.1、什么是生产者-消费者模式？ 比如有两个线程A和B，它们共享一个固定大小的数组，A线程产生数据放入数组，B线程从数组中取出数据进行计算，那么这里其实就是一个生产者和消费者的模式，A相当于生产者，B相当于消费者。 1.2、为什么要使用生产者消费者模式？ 在多线程开发中，如果生产者生产数据的速度很快，而消费者消费数据的速度很慢，那么生产者就必须等待消费者消费完了数据才能够继续生产数据，因为生产那么多也没有地方放啊；同理如果消费者的速度大于生产者那么消费者就会经常处理等待状态，所以为了达
解决线程死锁问题的 生产者 消费者程序.rar_linux_linux 线程_生产者_生产者 消费者_生产者消费者
09-20
为了解决生产者-消费者问题，开发者可能会使用互斥锁（mutexes）来保护对缓冲区的访问，使用条件变量（condition variables）来实现线程间的同步。互斥锁确保任何时候只有一个线程能访问缓冲区，而条件变量允许线程...
consumer_producer.rar_生产者消费者
09-14
在生产者消费者问题中，我们可以设置两个信号量：一个是互斥信号量，用于保护缓冲区不被同时读写；另一个是计数信号量，表示缓冲区中可用的位置数量。 2. **管程（Monitor）**：管程是Dijkstra提出的高级同步机制，...
生产者和消费者模型实现（基于条件变量）
M_jianjianjiao
11-27 545
基于条件变量的生产者和消费者模型实现 我们在这里使用使用一个生产者和一个消费者来实现。 并且使用一个定容的队列来作为两者的缓冲区域，即交易场所。 生产者与消费者模型及条件变量理解点这里 基本思路： 生产者向队列中放入数据 消费者从队列中拿走数据 存放数据的队列最为两者共享区域，必须进行互斥访问，使用互斥量 保持同步，避免饥饿问题。使用条件变量 当队列为空时，消费者进行等待，直到被生产者唤醒 消费...
使用条件变量实现生产者消费者模型
weixin_74474546的博客
05-30 171
使用条件变量实现生产者和消费者模型，生产者有5个，往链表头部添加节点，消费者也有5个，删除链表头部的节点。
使用条件变量实现生产者和消费者模型
m0_60663280的博客
11-28 411
生产者消费者模型，使用链表来实现，生产者依次创建链表节点，消费者访问链表中节点的数据域，然后删除（消费）。 创建两个线程来实现的过程中会产生一些问题，例如节点还未创建出来，消费者线程先得到CPU先执行，会出现错误等。 因此引入条件变量，等待生产者进程执行后，消费者进程在执行就不会发生错误了。 条件变量 条件本身不是锁！但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。 使用互斥量保护共享数据; 使用条件变量可以使线程阻塞, ...
C++11多线程编程——生产消费者模型之条件变量
m0_47313541的博客
05-04 411
在生产消费者模型当中，肯定都会用到互斥锁的机制的，当生产者往队列中放数据的瞬间，消费者是不能取数据的，那这时候可能会碰见一个问题，如果生成者因为某些原因，放数据过慢，但是消费者取数据很快，当队列中没有数据了，消费者还去取的话，就会发生异常情况。在很多情况下，这都容易适用，但是有些情况下，却会产生一些异常情况。这时候我们设想，能否设计这样的一种机制，如果在队列没有数据的时候，消费者线程能一直阻塞在那里，等待着别人给它唤醒，在生产者往队列中放入数据的时候通知一下这个等待线程，唤醒它，告诉它可以来取数据了。
【Linux】多线程同步--基于阻塞队列的生产者消费者模型（条件变量解决）
呋喃吖的博客
05-20 558
文章目录线程同步条件变量条件变量相关接口生产者消费者模型基本理论基于阻塞队列的生产者消费者模型 线程同步 什么是线程同步？ 首先先了解一下：互斥锁带来的一个问题：就是线程饥饿现象：就是多个线程长时间访问不到共享资源，不得已使得线程的执行流得以推进执行，这种现象就是线程饥饿现象！ 有线程饥饿线程的原因就是互斥锁带来的问题！ 有一种场景是，当一个线程A获得锁时候，进入临界区，访问结束后，释放锁，该线程A大概率的竞争能力比其他线程更加强，有可能重新获得锁，再次访问临界区！而其他线程可能竞争力不够强，长时间无法获
【操作系统】生产者消费者问题(使用互斥量和条件变量）
最新发布
modi000的博客
02-21 1643
例如(调换后)，将consumer的两个wait调换，在producer发出signal信号后，如果producer线程此时再次获得运行机会，执行完了wait(space)，此时，另一个consumer线程获得运行机会，执行了 wait(mutex) ，如果此时缓冲区为空，那么consumer将会阻塞在wait(items)，而producer也会因为无法获得锁的所有权所以阻塞在wait(mutex)，这样两个线程都在阻塞，也就造成了死锁。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。
多线程-生产者消费者模型，条件变量的使用，阻塞队列的实现
Zebra的博客
01-05 547
因为我们在调用pthread_cond_wait的时候，一般都是占用着锁的（一般都是检测到临界资源，发现不满足条件，才会调用这个wait方法），此时如果不把锁释放，直接wait的话，那就死锁了，其他线程也无法获取锁，修改这个临界资源。当消费者Pop取走任务的时候，同理要判断队列是否为空，如果空了就让消费者等待，然后加锁对队列进行操作，最后唤醒生产者来生产队列中的任务。暂时等待，而不是一直尝试抢票，如果一直抢票，抢票线程会一直获取锁，然后判断是否有票，没票，释放锁，不停循环这个操作，做无用功，而且占用锁。
消费者/生产者(条件变量)
杨杨杨~~的博客
06-11 308
消费者/生产者(条件变量) 在这里我以画图的形式来说明它的设计思路 代码如下(代码中的注释很全，方便理解): import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.locks.Condition; imp...
C++之生产者和消费者模型分析（条件变量）
weixin_65743593的博客
02-06 1013
C++之生产者和消费者模型分析（条件变量）
C++ 使用条件变量实现生产者和消费者模式
编程猿来如此
03-25 2871
C++ 使用条件变量实现生产者和消费者模式
Linux多线程同步：生产者-消费者问题解决方案
在本设计中，目标是通过Linux的线程机制和信号量来实现并发控制，确保生产者和消费者线程之间的正确协调。具体要求包括： 1. **有界缓冲区**：存在一个大小为20的缓冲区，用于存储1到20的整型数。生产者线程负责将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值