【Linux】生产者消费者模型

最新推荐文章于 2024-09-03 20:17:21 发布
最新推荐文章于 2024-09-03 20:17:21 发布
阅读量577 收藏
点赞数
分类专栏： linux 文章标签： c++ 服务器 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40376612/article/details/130531621
版权

生产者消费者模型

什么是生产者消费者模型

生产消费模型可以总结为：123规则

123规则：
1：一个线程安全的队列 （具有互斥+同步）
2：两种角色的线程 （生成者线程+消费者线程）
3：三种关系：生产者之间互斥，消费者之间互斥，生产者和消费者之间互斥+同步

生产者消费者模型的优点

忙闲不均：如果消费者只是每隔一秒从队列中取出数据，而生产者没有限制，随时高速往队列中放数据
生产者和消费者解耦
支持高并发和高可用

c++模拟实现生产者消费者模型

先创建一个线程安全的队列

#pragma once
#include<queue>
#include<pthread.h>

#define CAPACITY 1

class SafeQueue
{
public:
  SafeQueue()
  {
    pthread_mutex_init(&lock_, NULL);
    pthread_cond_init(&cons_cond_, NULL);
    pthread_cond_init(&prod_cond_, NULL);
    capacity_ = CAPACITY;
  }
  ~SafeQueue()
  {
    pthread_mutex_destroy(&lock_);
    pthread_cond_destroy(&cons_cond_);
    pthread_cond_destroy(&prod_cond_);
  }

  void push(int data)
  {
    pthread_mutex_lock(&lock_);
    while(que_.size() >= capacity_)
    {
      pthread_cond_wait(&prod_cond_, &lock_);
    }
    que_.push(data);
    pthread_mutex_unlock(&lock_);
    pthread_cond_signal(&cons_cond_);
  }

  void pop(int *data)
  {
    pthread_mutex_lock(&lock_);
    while(que_.empty())
    {
      pthread_cond_wait(&cons_cond_, &lock_);
    }
    *data = que_.front();
    que_.pop();
    pthread_mutex_unlock(&lock_);
    pthread_cond_signal(&prod_cond_);
  }

private:
  std::queue<int> que_;
  pthread_mutex_t lock_;
  pthread_cond_t cons_cond_;
  pthread_cond_t prod_cond_;
  size_t capacity_;
};

再创建一个生产消费者模型

#pragma once
#include<stdio.h>
#include<unistd.h>
//#include<pthread.h>
#include<iostream>
#include"safe_queue.hpp"


class ConsAndProd
{
public:
  ConsAndProd(int tc = 1)
  {
    sq_ = NULL;
    thread_count_ = tc;
    data_ = 0;
    pthread_mutex_init(&lock_d, NULL);
  }
  ~ConsAndProd()
  {
    if(sq_)
    {
      delete sq_;
    }
    pthread_mutex_destroy(&lock_d);
  }

  int OnInit()
  {
    sq_ = new SafeQueue();
    if(sq_ = NULL)
    {
      return -1;
    }
    return 0;
  }

  int start()
  {
    for(int i = 0; i < thread_count_; ++i)
    {
      pthread_t tid;
      int res = pthread_create(&tid, NULL, ConsStart, (void*)this);
      if(res < 0)
      {
        return -1;
      }
      res = pthread_create(&tid, NULL, ProdStart, (void*)this);
      if(res < 0)
      {
        return -1;
      }
    }
  }

  static void* ConsStart(void* arg)
  {
    pthread_detach(pthread_self());
    ConsAndProd* cap = (ConsAndProd*)arg;
    while(1)
    {
      int data;
      cap->sq_->pop(&data);
      printf("i am cons_thread%p, i cons%d\n", pthread_self(), data);
    }
    return NULL;
  }
  static void* ProdStart(void* arg)
  {
    pthread_detach(pthread_self());
    ConsAndProd* cap = (ConsAndProd*)arg;
    while(1)
    {
      pthread_mutex_lock(&cap->lock_d);
      cap->sq_->push(cap->data_++);
      pthread_mutex_unlock(&cap->lock_d);
      sleep(1);
    }
    return NULL;
  }

private:
  SafeQueue* sq_;
  int data_;
  pthread_mutex_t lock_d;
  int thread_count_;
};

最后创建一个main入口函数

#include"cons2prod.hpp"

int main()
{
  ConsAndProd* cap = new ConsAndProd(2);
  if(cap->OnInit() < 0)
  {
    std::cout << "init safe_queue failed\n";
    return 0;
  }
  if(cap->start() < 0)
  {
    std::cout << "Cons_prod create failed\n";
    return 0;
  }

  while(1)
  {
    sleep(1);
  }
  delete cap;
  return 0;
}

信号量

信号量的本质是资源计数器+PCB等待队列，与条件变量相比，只是多了一个资源计数器。有了资源计数器后，达到无冲突的访问共享资源目的。

信号量：既能使用信号量进行互斥，又能使用信号量进行同步。

在这里插入图片描述

信号量的初始化

#include<semaphore.h>
int sem_init(sem_t *sem, init pshared, unsigned int value);

参数：
pshared: 0表示线程间共享，非0表示进程间共享
value：信号量初始值，即有多少个资源

销毁信号量

int sem_destroy(sem_t *sem);

等待信号量

int sem_wait(sem_t *sem);
//注意：调用等待函数，会进入PCB等待队列，并且信号量的值会减1，
//判断资源计数器的值是否小于0， 是：阻塞等待，将执行流放到PCB等待队列，否：则接口返回

发布信号量

int sem_post(sem_t *sem);
//注意：调用post函数，会将当前资源++，也就是信号量加1，表示有资源被释放，
//判断资源计数器的值是否小于等于0，是：通知PCB等待队列，否：不用通知，因为没有线程在等待

基于信号量重新对生产消费模型进行设计

创建一个线程安全的队列

#pragma once 
#include<queue>
#include<semaphore.h>

class safequeue
{
public:
  safequeue()
  {
    sem_init(&_lock, 0, 1);
    sem_init(&cons_sem, 0, 0);
    sem_init(&prod_sem, 0, 2);//初始只有一个空闲资源,现在改为2
  }

  ~safequeue()
  {}

  void push(int data)
  {
    //先保证对于生产者而言，是有资源的，有资源再去抢_lock
    //实际上就是要先保证同步
    sem_wait(&prod_sem);
    //当生产者有资源时，要保证生产者之间是互斥的，所以要抢_lock
    //实际上就是要保证互斥
    sem_wait(&_lock);
    _que.push(data);
    //当某一个生产者生产完，需要释放_lock，让其他生产者生产
    sem_post(&_lock);
    //当生产者生产完，需要通知消费者来消费
    sem_post(&cons_sem);

  }

  void pop(int* data)
  {
    sem_wait(&cons_sem);
    sem_wait(&_lock);
    *data = _que.front();
    _que.pop();
    sem_post(&_lock);
    sem_post(&prod_sem);
  }
private:
  std::queue<int> _que;
  /*
   * 保证多个线程互斥访问，
   * */
  sem_t _lock;
  //消费者信号量，初始化资源为0，后期资源个数由生产者加
  sem_t cons_sem;
  //生产者信号量，描述队列的空闲空间，初始化由程序员定，后期资源个数由消费者加
  sem_t prod_sem;
};

创建两个角色，保证互斥和同步

#include<stdio.h>
#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include"safequeue.hpp"


#define THREADCOUNT 2
int g_count = 0;

void* consstart(void* arg)
{
  safequeue* sq = (safequeue*)arg;
  while(1)
  {
    int data;
    sq->pop(&data);
    printf("i cons %d\n", data);
  }
  return NULL;
}
void* prodstart(void* arg)
{
  safequeue* sq = (safequeue*)arg;
  sem_t lock_count;
  sem_init(&lock_count, 0, 1);
  while(1)
  {
    sq->push(g_count); 
    //由于当前有2个生产者和消费者，对于g_count而言，就不是线程安全的。需要加锁保护
    sem_wait(&lock_count);
    g_count++;
    sem_post(&lock_count);
    //sleep(1);
  }
  sem_destroy(&lock_count);
  return NULL;
}


int main()
{
  /*创建两种角色的线程*/
  safequeue* sq = new safequeue();
  if(sq == NULL)
  {
    return 0;
  }
  pthread_t cons[THREADCOUNT], prod[THREADCOUNT];
  for(int i = 0; i < THREADCOUNT; ++i)
  {
    int res = pthread_create(&cons[i], NULL, consstart, (void*)sq);
    if(res < 0)
    {
      return 0;
    }
    res = pthread_create(&prod[i], NULL, prodstart, (void*)sq);

  }

  for(int i = 0; i < THREADCOUNT; ++i)
  {
    pthread_join(cons[i], NULL);
    pthread_join(prod[i], NULL);
  }
  delete sq;
  return 0;
}

基于环形队列的生产消费模型

注意：实际上，我们看到的当前操作系统中缓冲区大多数都是用环形队列来设计的。

首先我们看下一个队列是如何工作的：生产者先向队列中push数据，顺序是0—>n，当队列中有数据时，消费者就可以从队列中pop数据。
在这里插入图片描述

因为队列的空间不可能无穷大，所以当消费者一直不消费时，生产者就会将队列填满，那么就如下图所示，生产者指向的是队列的尾部。
在这里插入图片描述

此时，若有消费者从0下标的位置进行消费，就会将0位置的元素pop，生产者就需要从队列的末尾指向队列的头部。

可问题是，怎么样才能让生产者指向队列的头部呢？
我们可以通过模运算来实现。
设置一个生产/消费下标值，生产/消费一次后，下标值++，然后将当前下标值%队列长度。

在这里插入图片描述

使用这样的模运算，就能让下标从队尾指向对头，看起来就像是一个环形一样，这样就实现了环形队列。

如果用上述生产消费者模型来写的话，只需要改变push和pop的部分代码即可

#pragma once 
#include<queue>
#include<semaphore.h>

class safequeue
{
public:
  safequeue()
  {
    sem_init(&_lock, 0, 1);
    sem_init(&cons_sem, 0, 0);
    sem_init(&prod_sem, 0, 4);//设置初始空闲资源为4
    //往队列中读和写的初始值为0
    pos_r = 0;
    pos_w = 0;
  }

  ~safequeue()
  {}

  void push(int data)
  {
    //先保证对于生产者而言，是有资源的，有资源再去抢_lock
    //实际上就是要先保证同步
    sem_wait(&prod_sem);
    //当生产者有资源时，要保证生产者之间是互斥的，所以要抢_lock
    //实际上就是要保证互斥
    sem_wait(&_lock);
    //原代码
    //_que.push(data);
    //修改为环形队列的代码
    arr[pos_w] = data;
    pos_w = (pos_w + 1) % 4;//更新位置
    //当某一个生产者生产完，需要释放_lock，让其他生产者生产
    sem_post(&_lock);
    //当生产者生产完，需要通知消费者来消费
    sem_post(&cons_sem);

  }

  void pop(int* data)
  {
    sem_wait(&cons_sem);
    sem_wait(&_lock);
    //原代码
    //*data = _que.front();
    //_que.pop();
    //替换为环形队列的代码
    *data = arr[pos_r];
    pos_r = (pos_r + 1) % 4;//更新位置
    sem_post(&_lock);
    sem_post(&prod_sem);
  }
private:
  //不使用queue的结构
  //std::queue<int> _que;
  //为了验证环形队列，使用数组的结构，保证空间大小固定为4
  int arr[4];
  /*
   * 保证多个线程互斥访问，
   * */
  sem_t _lock;
  //消费者信号量，初始化资源为0，后期资源个数由生产者加
  sem_t cons_sem;
  //生产者信号量，描述队列的空闲空间，初始化由程序员定，后期资源个数由消费者加
  sem_t prod_sem;
  //增加了两个往队列中读和写的位置
  int pos_r;
  int pos_w;
};
德拉库斯
关注
专栏目录
linux生产者消费者
12-03
操作系统linux生产者消费者实验，有需要的请下载
Linux--生产者与消费者
哥不帅但很坏的博客
06-30 3001
基于单链表的生产者消费者模型。基于环形队列的生产者消费者模型。 生产者消费者问题，其实是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程—即所谓的“生产者”和“消费者”–在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放在缓冲区中，消费者在缓冲区消耗这些数据。但是，要保证生产者不会在缓冲区满时还往缓冲区写数据，消费者也不会在缓冲区为空时
【Linux操作系统】：Linux生产者消费者模型
最新发布
元清的博客
09-03 1110
生产者和消费者彼此之间不直接通讯，而通过这个容器来通讯，所以生产者生产完数据之后不用等待消费者处理，直接将生产的数据放到这个容器当中，消费者也不用找生产者要数据，而是直接从这个容器里取数据，这个容器就相当于一个缓冲区，平衡了生产者和消费者的处理能力，这个容器实际上就是用来给生产者和消费者解耦的。例如，我们想要实现一个基于计算任务的生产者消费者模型，此时我们只需要定义一个Task类，这个类当中需要包含一个Run成员函数，该函数代表着我们想让消费者如何处理拿到的数据。为了方便理解，我们以。
Linux 下C语言实现生产者、消费者模型
m0_53503776的博客
06-29 540
1）最好用2个条件变量实现，一个用于生产者，一个用于消费者，避免只用一个条件变量时且多个消费者时，消费者会唤醒消费者；4）wait的时候会临时释放掉锁，待条件满足被唤醒后会该线程会重新持有锁，所以wait的参数要传锁下去；3）条件变量前的条件判断需要用while，不能用if，避免虚假唤醒；2）需要加锁，尤其是在调用signal时要持有锁；
Linux 生产者/消费者
weixin_48560325的博客
11-28 1574
生产者消费者 生产者消费者问题概述 生产者/消费者问题，也被称作有限缓冲问题。可以描述为：两个或者更多的线程共享同一个缓冲区，其中一个或多个线程作为“生产者”会不断地向缓冲区中添加数据，另一个或者多个线程作为“消费者”从缓冲区中取走数据。生产者/消费者模型关注的是以下几点： *生产者和消费者必须互斥的使用缓冲区 *缓冲区空时，消费者不能读取数据 *缓冲区满时，生产者不能添加数据 生产者消费者模型优点： 解耦：因为多了一个缓冲区，所以生产者和消费者并不直接相互调用，这样生产者和消费者的代码 发生变化，都不会
linux进程链、进程扇和信号量实现生产者--消费者模型实验报告
12-26
通过对生产者-消费者模型的实现，学生将学习如何在Linux环境下运用无名信号量来保护临界资源，同时提升对文件I/O操作的掌握。 二、实验内容 实验分为三个部分： 1. 使用链式结构创建10个子进程，形成进程链。 2. ...
Linux生产者消费者模型浅析
01-09
　试想如果没有缓冲区，生产者生产一个数据之后，必须等待消费者消费完成，生产者才能继续生产，那么如果生产者很快，而消费者很慢，那么只能让生产者干等。这好比让CPU和外设直接打交道，如果没有缓存，还不得慢死...
linux生产者消费者模型
03-16
Linux生产者消费者模型是一种并发编程模型，用于解决多线程或多进程之间的同步问题。在该模型中，生产者负责生产数据，消费者负责消费数据，两者通过共享的缓冲区进行通信。当缓冲区为空时，消费者等待生产者生产...
Linux生产者消费者模型解析：概念与模拟
"本文主要介绍了Linux环境下的生产者消费者模型，包括其基本概念、关系以及一个简单的模拟示例。" 在计算机系统设计中，生产者消费者模型是一种经典的多线程同步问题模型，常用于处理数据处理流程中的异步操作。...
浅谈生产者消费者模型(Linux系统下的两种实现方法)
09-15
总结来说，生产者消费者模型在Linux下的实现主要依赖于同步机制，如信号量和互斥锁，以确保生产者和消费者之间的协同工作，防止资源过度消耗或耗尽。这两种实现方式各有特点，可以根据实际需求选择合适的同步机制。...
linux下的生产者与消费者
04-24
linux下的生产者与消费者实例，C实现，有注释，翻译的某个window下生产者与消费者的例子
Linux——生产者消费者模型
weixin_46107667的博客
06-21 304
Linux——生产者消费者模型
Linux----生产者与消费者
qq_48083892的博客
12-08 1771
生产者与消费者
Linux下生产者消费者 实现
colder2008的专栏
08-16 838
<br />底层用链表实现的生产者和消费者队列，能够同时支持多个读写线程。<br /> <br />#include <pthread.h> #include <stdio.h> #include <string.h> #include <unistd.h> #define MAXLINE (32) struct user_data { unsigned int n_size; char line[MAXLINE]; }; struct task { str
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值