121-多线程开发：生产者消费者模型、条件变量、信号量

最新推荐文章于 2024-05-31 14:19:08 发布
最新推荐文章于 2024-05-31 14:19:08 发布
阅读量335 收藏
点赞数
分类专栏： Linux系统编程 文章标签： 链表 数据结构 linux 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Edward_LF/article/details/124527469
版权

12、生产者消费者模型

通知机制（目前还实现不了，条件变量和信号量）
生产者满了，会阻塞在那里，通知消费者消费；
消费者消费完之后，消费者也会阻塞在那里；

数据同步 和 数据满了或者没有数据的相互通知机制

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

//定义链表节点
struct Node{
    int num;
    struct Node *next;
};

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

void * producer(void * arg) {

    // 不断的创建新的节点，添加到链表中
    while(1) {
        //头插法
        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());
        usleep(100);
    }

    return NULL;
}

void * customer(void * arg) {

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

        // 判断是否有数据
        if(head != NULL) {
            // 有数据
            head = head->next;
            printf("del node, num : %d, tid : %ld\n", tmp->num, pthread_self());
            free(tmp);
        }
    }
    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_exit(NULL);

    return 0;
}

执行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eR6wl6xu-1651389571117)(../../../assets/多线程开发/image-20220117200849789.png)]

执行一段时间为什么会产生段错误？

查看穿产生段错误的原因：

生成core文件；

gcc prodcust.c -o produst -pthread -g

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oCu8fJ1t-1651389571119)(../../../assets/多线程开发/image-20220117201759504.png)]

gdb prodcust

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UinPq6uS-1651389571120)(../../../assets/多线程开发/image-20220117201845707.png)]

core-file core

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gJ5jjulW-1651389571121)(../../../assets/多线程开发/image-20220117202023338.png)]

错误原因： 如果head为空，访问head->next就会出现段错误（也就是共享数据区没有数据时，就会出现错误）

需要使用信号量：

共享数据中满了，通知消费者消费；

没有数据之后，消费者通知生产者去生产。

13、条件变量

使用互斥量解决数据不同步的问题。

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

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

//定义链表节点
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_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);

    pthread_exit(NULL);

    return 0;
}

缺点： 若果共享区中一直没有数据，消费者就会一直循环判断，浪费资源。

改进做法: 没有数据，消费者通知生产者生产，生产者生产之后，通知消费者消费。

条件变量：（不是锁，配合锁使用）
某个条件满足了，引起线程阻塞；
某个条件满足了，解除线程阻塞；

通过互斥锁来解决线程同步问题。

/*
    条件变量的类型 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);
        - 唤醒所有的等待的线程
*/
#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 {
            // 没有数据，需要等待
            // 当这个函数调用阻塞的时候，会对互斥锁进行解锁，当不阻塞的(生产者执行pthread_cond_signal(&cond)后)，继续向下执行，会重新加锁。
            pthread_cond_wait(&cond, &mutex);	//生产者执行pthread_cond_signal(&cond)后，此时就不会阻塞了，继续执行while(1)循环
            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;
}

14、信号量

和条件变量做的事情类似，也适用于阻塞线程的，信号量又称信号灯：

  • 灯亮：表示资源可用；
  • 灯灭：表示资源不可用；

信号量和条件变量都是阻塞线程的，均不能保证数据的安全，要保证安全的话，和锁一起使用。

/*
    信号量的类型 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);

    sem_t psem;
    sem_t csem;
    init(psem, 0, 8);  生产者相当于容量
    init(csem, 0, 0);

    producer() {
        sem_wait(&psem);	//对psem值-1，剩余的容量，7，意思就是：生产了一个，容量-1
        sem_post(&csem)		//对csem值 +1, 生产了一个，+1
    }

    customer() {
        sem_wait(&csem);	//对csem的值-1，一开始为0，阻塞
        sem_post(&psem)		//对psem的值+1,  表示容量增+1
    }

*/

#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
        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
    }

    return NULL;
}

void * customer(void * arg) {

    while(1) {
        sem_wait(&csem);	//消费者首先将自己的可以消费的资源-1
        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);	//将生产者的容量+1
       
    }
    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;
}
liufeng2023
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Sistemas-Concurrentes-Distribuidos-Productor-Consumidor-Semaforos:基于信号量解决生产者-消费者问题LIFO和FIFO
06-22
scd-生产者-消费者-交通灯基于信号量的 LIFO 和 FIFO 生产者-消费者问题的解决方案。问题与应用当您想设计一个程序时，会出现消费者生产者问题，其中一个进程或线程在内存中生成另一个进程或线程使用的数据项。 一般...
使用信号量实现生产者消费者|C语言
lin3ux的博客
05-09 1858
本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。 Intro 本文为多生产者多消费者的C语言实现 生产者与消费者针对链表的头结点进行操作 使用的现场同步方法为信号量 本文侧重于理解条件变量的使用 为保证代码简洁，本文代码没有对函数的返回值进行检查，聪明的你一定一定知道如何检查这个小细节(•̀ᴗ•́)و ̑̑ 关于互斥锁+条件变量的多生产者多消费者模型实现请参考我的这篇博客 analysis 多生产者多消费者有多个线程，当根据信号量定义的资源数不同，所对应的情况也有所不.
3.12-3.14生产者和消费者模型、条件变量、信号量
m0_38062470的博客
02-25 112
目录 1.生产者消费者模型 2.条件变量 3.信号量 1.生产者消费者模型 2.条件变量 3.信号量 初始化的值：生产者-目前可以生产几个 -n 消费者-目前可以消费几个 -0 ...
多线程操作：互斥、同步与信号量（生产者消费者模型两种实现方式）
唐学长的博客
05-03 1877
互斥与同步的概念 基于锁实现互斥与同步 基于条件变量和锁实现同步 基于阻塞队列的生产者与消费者模型 什么是信号量？ 基于信号量的生产者与消费者模型
【Linux】线程：生产者-消费者模型 & 信号量
Dooo_yh的博客
06-07 370
解析线程的 “生产者-消费者模型”、线程信号量
多线程之生产者-消费者问题（信号量机制）
碣石观海的博客
04-28 3528
一、生产者消费者问题 生产者-消费者问题，简单描述就是，生产者向仓库中存入生产的产品，消费者从仓库中取走产品消费。 需要满足的三个条件： 1.如果仓库已满，那么生产者不能再向仓库中存入产品，只能等待仓库有空闲； 2.如果仓库为空，那么消费者无法从仓库中取出任何产品进行消费，只能等待仓库有库存产品； 3.生产者和消费者不能同时访问仓库。 注1：条件1和2即是满足了生产者与消费者间的同步，...
操作系统课内实习，模拟生产者、消费者模型
07-19
内容概要：基于QT Creator环境的多线程编程验证互斥的原理，通过使用semaphore，mutex等控制变量，实现对生产者消费者模型的真实模拟。 适合人群：初学操作系统的学生 能学到什么：调用了Qt多线程类库QThread进行...
消费者生产者模型 c++
09-25
//生产者允许消费者开始消费的信号量； CRITICAL_SECTION PC_Critical[MAX_BUFFER_NUM]; DWORD n_Thread = 0; //实际的线程的数目； DWORD n_Buffer_or_Critical; //实际的缓冲区或者临界区的数目； //生产消费...
Java多线程编程总结
01-14
Java线程：并发协作-生产者消费者模型 Java线程：并发协作-死锁 Java线程：volatile关键字 Java线程：新特征-线程池 Java线程：新特征-有返回值的线程 Java线程：新特征-锁（上） Java线程：新特征-锁（下） ...
java多线程编程总结
08-26
Java线程：并发协作-生产者消费者模型 Java线程：并发协作-死锁 Java线程：volatile关键字 Java线程：新特征-线程池 Java线程：新特征-有返回值的线程 Java线程：新特征-锁（上） Java线程：新特征-锁（下） Java...
Linux C/C++生产者消费者模型-条件变量-信号量
Abieai的博客
04-25 1757
文章目录一、生产者消费者模型1.生产者消费者模型是什么2.生产者消费者简单代码案例(互斥锁解决)二、条件变量解决1.条件变量是什么2.条件变量常用函数3.条件变量解决问题三、信号量解决1.信号量是什么2.信号量函数3.信号量解决总结 一、生产者消费者模型 1.生产者消费者模型是什么 生产者消费者模式 是Controlnet网络中特有的一种传输数据的模式。用于两个CPU之间传输数据，即使是不同类型同一厂家的CPU也可以通过设置来使用。 2.生产者消费者简单代码案例(互斥锁解决) #include<
线程同步之条件变量和信号量（生产者消费者模型）
一条二哈
01-10 1490
条件变量是什么 条件变量是线程可用的一种同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件产生。 条件变量本身是由互斥量保护的。线程在改变条件状态之前必须首先锁住互斥量。其他线程在获得互斥量之前不会察觉到这种改变，因为互斥量必须在锁定以后才能计算条件。 在使用条件变量之前必须进行初始化，可以把常量 PTHREAD_COND_INIT...
C++多线程框架 （二）---------Mutex互斥和Sem信号量
笑笑的程序人生
05-23 7022
互斥和信号量是多线程编程的两个基础，其原理就不详细说了，大家去看看操作系统的书或者网上查查吧。 对于互斥的实现，无论什么操作系统都离不开三个步骤 1.初始化互斥锁 2.锁操作 3.解锁操作 对于不同的系统只是实现的函数有一些不同而已，但是功能其实都大同小异，在锁操作和解锁操作的时候大部分系统都有超时机制在里面，来保证不会一直锁在某个地方，我们为了框架简单，没有设置超时，进行锁操作
c++多线程之条件变量及生产消费者模型
weixin_42579072的博客
11-13 311
一、condition_variable 类介绍 当 std::condition_variable 对象的某个 wait 类函数被调用的时候，它使用std::unique_lock（通过 std::mutex）来锁住当前的线程，当前的线程会一直被阻塞（进入睡眠等待状态），直到有其他的线程在同一个 std::condition_variable 对象上调用 notify 类函数来唤醒它。 std:...
linux---生产者和消费者模型(条件变量和信号量实现)
boke_fengwei
05-20 2441
问题的提出 在我们对一些全局变量的进行非原子性操作的时候就可能出现非线程安全，比如我们吃面的问题。 我们做面的人就是生产者，吃面的人就是我们的消费者，当我们的消费者需要吃面的时候就唤醒我们的生产者进行生产，当我们有面的时候我们的生产者就不继续生产面条，去唤醒我们的消费者进行消费。 生产者和消费者模型： - 如何保证生产者与消费者的线程安全？ - 生产者与生产者应该具有互斥关系 - 消费者...
c++ 多线程 生产者与消费者模型
师范大学生的博客
06-12 2204
前言   在多线程中，生产者与消费者模型是一个非常经典的问题。   假设有一个厨师做馒头，另外一个顾客吃厨师做的馒头，这样生产者（厨师）和消费者（顾客）两个元素就到位了。一般来讲，厨师做馒头的速度和顾客吃馒头的速度应该是不一样的，如果厨师做馒头的速度比顾客吃馒头的速度快，那么一定时间后一定是馒头堆积如山顾客永远也吃不完；如果厨师做馒头的速度比顾客吃馒头的速度慢，那么一定时间后一定是餐桌空空厨师永远不能停下工作。   显然这个结果一般是人们不愿意看到的，于是我们希望有一种机制，能够对厨师和顾客的行为进行一定的
线性数据结构-数组
最新发布
passworddddddd的博客
05-31 186
因为数组定长，当想往长度为8的数组中添加第九个元素时，操作系统会开辟一段长度为16的新的空间（操作系统会开辟一些提前量，多划一些空间），然后将旧数组的八个元素复制到新的数组中，并将新添加的元素，添加到新数组的第九个位置上，并且销毁就数组。1、因为空间必须是连续的，如果数组比较大，当系统的空间碎片较多时，容易存不下。在长度8的数组中删除第5个元素，不改变数组长度，从第六个元素开始向左移动一个单元，即数组删除。2、因为数组长度是固定，所以数组的内容难以被添加和删除。3、数组的变量指向了数组第一个元素的位置。
C语言.数据结构.单链表
Joseit的博客
05-31 748
C语言数据结构单链表技术博客文章摘要 本文深入探讨了C语言中的数据结构——单链表。首先，文章介绍了链表的概念及结构，强调了链表作为一种物理存储结构上非连续、非顺序的存储结构，其数据元素的逻辑顺序是通过链表中的指针链接次序实现的。通过将链表与火车车厢的类比，形象地展示了链表节点之间的独立性和链接关系。 接着，文章详细阐述了单链表的实现方法，包括定义链表节点结构体、实现基本的链表操作（如头部插入、删除、尾部插入、删除、查找、在指定位置插入/删除节点等），以及链表的销毁等功能。
C-数据结构-树状存储基本概念
aqiangdeba的博客
05-27 793
’’树状存储基本概念深度（层数）度（子树个数）叶子孩子兄弟堂兄弟二叉树：满二叉树：完全二叉树：存储：顺序，链式树的遍历：按层遍历，先序，中序，后序‘’’树是计算机科学中的一种重要数据结构。以下是关于树的基本概念和类型的详细介绍。
多线程生产者消费者问题
09-03
多线程生产者消费者问题是指在多线程环境下，存在生产者线程和消费者线程，它们共享一个有限容量的缓冲区。生产者线程的任务是往缓冲区中生产数据，而消费者线程的任务是从缓冲区中消费数据。生产者线程和消费者线程需要通过同步机制来确保缓冲区的安全访问，避免数据竞争和死锁的发生。 常见的解决方案有以下几种： 1. 使用锁机制：可以使用互斥锁（mutex）来保护共享资源，生产者和消费者在访问缓冲区之前需要先获得锁，操作完成后再释放锁，以实现互斥访问。 2. 使用条件变量：生产者和消费者可以使用条件变量（condition variable）来进行等待和唤醒操作。当缓冲区为空时，消费者线程等待；当缓冲区已满时，生产者线程等待。当有新数据生产或数据被消费后，通过条件变量进行通知。 3. 使用信号量：可以使用信号量（semaphore）来控制生产者和消费者的数量。通过设置信号量的初始值和对信号量进行 P（等待）和 V（释放）操作，可以实现对生产者和消费者线程的同步控制。 这些方法都可以用来解决多线程生产者消费者问题，具体选择哪种方法取决于具体的需求和使用场景。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

liufeng2023

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值