Linux---生产者消费者模型、信号量、基于环形队列的生产者消费者模型、线程池

最新推荐文章于 2023-12-02 23:22:20 发布

疯狂嘚程序猿

最新推荐文章于 2023-12-02 23:22:20 发布

阅读量680

点赞数 7

分类专栏： Linux 文章标签：操作系统多线程 linux

本文链接：https://blog.csdn.net/qq_47406941/article/details/115642452

版权

Linux 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

一、生产之消费者模型

1、什么是生产者消费者模型？

2、生产者消费者模型的优点

3、基于Blocking Queue的生产者消费者模型

一、生产之消费者模型

1、什么是生产者消费者模型？

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。

总结：“321”模型

3种关系：生产者和生产者之间是互斥关系（只有一个生产者可以通过临界区向临界资源写入）；生产者和消费（同步）；消费者和消费者（互斥）。
2种角色：生产者和消费者
1个交易场所：缓冲区（仓库）

2、生产者消费者模型的优点

生产者消费者模型，对具有很强耦合性的问题进行了解耦，同时支持高并发和“忙闲不均”。

3、基于Blocking Queue的生产者消费者模型

在多线程变成中阻塞队列（Blocking Queue）是一种常用于实现生产者消费者模型的数据结构。其与普通队列的区别在于，当队列为空时会阻塞从队列中取的操作，直到队列不为空；当队列为满时，会阻塞存放元素的操作，直到有元素被从队列中取出。

C++实现基于Blocking Queue的生产者消费者模型的实现

#include"ProducerConsumerModel.hpp"    
    
void* ProducerRun(void* bq)    
{    
    int count = 1;    
    while(true)    
    {    
        //每隔1秒生产一个    
        ((BlockingQueue*)(bq))->PutMessage(count);    
        std::cout<<"生产者：生产成功-->"<<count++<<std::endl;    
        sleep(1);    
    }    
}    
    
void* ConsumerRun(void* bq)    
{    
    sleep(1);                                                                                                                                                                              
    while(true)    
    {    
        //每隔2秒消费一个    
        int mesg;    
        ((BlockingQueue*)(bq))->GetMessage(mesg);    
        std::cout<<"消费者：消费成功-->"<<mesg<<std::endl;    
    }    
}    
    
int main()    
{    
    BlockingQueue *bq = new BlockingQueue;    
    //创建生产者和消费者线程：单生产者<--->单消费者    
    pthread_t p,c;//生产者消费者线程id：生产者->p 消费者->c    
    pthread_create(&p,NULL,ProducerRun,(void*)bq);    
    pthread_create(&c,NULL,ConsumerRun,(void*)bq);    
    //线程等待    
    pthread_join(p,NULL);    
    pthread_join(c,NULL);    
    return 0;    
}    

#ifndef __QUEUE_BLOCK_H_                                                                                                                                                                   
#define __QUEUE_BLOCK_H_
#include <iostream>
#include <pthread.h>
#include <queue>
#include <unistd.h>

class BlockingQueue
{
private:
    //empty方法---判断阻塞队列是否为空
    bool IsEmpty()
    {
        //如果size为0，为空表示假
        return !bq.size();
    }
    bool IsFull()
    {
        //当阻塞队列中的元素个数等于阻塞队列容量时，队列为满
        return bq.size() == capacity;
    }
    //full方法---判断阻塞队列是否为满
public:
    //构造函数---创建一个大小为NUM的阻塞队列
    BlockingQueue(size_t NUM = 8)
      :capacity(NUM)
    {
        //初始化条件变量和互斥量
        pthread_mutex_init(&mutex,NULL);
        pthread_cond_init(&p_cond,NULL);
        pthread_cond_init(&c_cond,NULL);
    }
    //put方法---向阻塞队列中放数据
    void PutMessage(int mesg)
    {
        //当队列为空时，消费者向生产者发送一个信号，生产者开始放数据
        pthread_mutex_lock(&mutex);
        while(IsFull())
        {
            pthread_cond_signal(&c_cond);
            std::cout<<"生产者：消费者，你可以请尽快消费..."<<std::endl;
            std::cout<<"生产者：等待中..."<<std::endl;
            pthread_cond_wait(&p_cond,&mutex);
        }
        bq.push(mesg);
        pthread_mutex_unlock(&mutex);
    }
    //get方法---从阻塞队列中获取数据
    void GetMessage(int& mesg)
    {
        //通过参数获取
        pthread_mutex_lock(&mutex);
        while(IsEmpty())
        {
            pthread_cond_signal(&p_cond);
            std::cout<<"消费者：生产者，请尽快生产..."<<std::endl;
            std::cout<<"消费者：等待中..."<<std::endl;
            pthread_cond_wait(&c_cond,&mutex);
        }
        mesg = bq.front();
        bq.pop();
        pthread_mutex_unlock(&mutex);
    }
    //析构函数---销毁条件变量和互斥量
    ~BlockingQueue()
    {
        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&p_cond);
        pthread_cond_destroy(&c_cond);
    }
private:
    std::queue<int> bq;//阻塞队列
    size_t capacity;//阻塞队列的大小                                                                                                                                                       
    pthread_cond_t p_cond;//生产者等待的条件变量
    pthread_cond_t c_cond;//消费者等待的条件变量
    pthread_mutex_t mutex;//互斥量
};
#endif

运行结果：

二、信号量

1、什么是信号量？

POSIX和System V信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源的目的。但是POSIX可以用于线程间资源的同步。

信号量的本质就是一个“计数器”！！！用来统计有效资源的数量，有两个操作（都是原子的）：

P操作：有效资源减少
V操作：有效资源增加

2、信号量的作用

思考：是否可以将临界区代码分成互不影响的块，一个线程（执行流）访问一个区域？

答案：可以，使用信号量对临界资源进行管理，使用P、V操作访问释放临界资源。多个线程并发运行，提高运行效率。

3、信号量的使用

1）初始化

int sem_init(sem_t *sem, int pshared, unsigned int value);

参数：
pshared:0表示线程间共享，非零表示进程间共享
value：信号量初始值

2）销毁

int sem_destroy(sem_t* sem);

3）等待

功能：等待信号量，会将信号量的值减1 p操作

int sem_wait(sem_t *sem);

4）发布

功能：发布信号量，表示资源使用完毕归还资源，信号量值加1 V操作

int sem_post(sem_t *sem);

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

1）环形队列

环形队列采用数组模拟实现，利用模运算模拟换装特性

环形结构的起始状态和结束状态都是一样的（head==tail）,不好判断未满或者为空，所以可以通过加标记为或者计数器判断满或者空，也可以通过预留一个空的位置作为满的状态

2）基于环形队列和信号量的生产者消费者模型的实现

#pragma once                                                                                                                                                                             
#include<iostream>
#include<vector>
#include<pthread.h>
#include<semaphore.h>
#include<unistd.h>
  
class RingQueue
{
private:
    void P(sem_t& sem)
    {
        //等待信号量，信号量的值-1
        sem_wait(&sem);
    }
    void V(sem_t& sem)
    {
        //发布信号量，信号量的值+1
        sem_post(&sem);
    }
public:
    RingQueue(size_t cap = 10)
        :capacity(cap)
         ,p_index(0)
         ,c_index(0)
         ,rq(cap)
    {
        //消费者的信号量初始值为0
        sem_init(&c_sem,0,0);
        //生产者的信号量初始值为capacity
        sem_init(&p_sem,0,capacity);
    }
    void PutMessage(int message)
    {
        //生产者放消息
        P(p_sem);
        rq[p_index++] = message;
        p_index %= capacity;
        V(c_sem);
    }
    void GetMessage(int& message)
    {
        P(c_sem);
        message = rq[c_index++];
        c_index %= capacity;
        V(p_sem);
    }
    ~RingQueue()
    {
        sem_destroy(&c_sem);
        sem_destroy(&p_sem);
    }
private:
    std::vector<int> rq;//用数组模拟环形队列
    size_t p_index;
    size_t c_index;
    sem_t p_sem;//生产者信号量
    sem_t c_sem;//消费者信号量
    size_t capacity;//环形队列的容量
};

#include"RingQueue.hpp" 
  void* consumer(void* arg)
  {
      RingQueue *rq = (RingQueue*)arg;
      int message;
      while(true)
      {
          rq->GetMessage(message);                                                                                                                                                       
          std::cout<<"comsumer : get a message-> "<<message<<std::endl; 
          sleep(1);
      }
      return nullptr;
  }
  
  void* producer(void* arg)
  {
      RingQueue *rq = (RingQueue*)arg;
      int count = 1;
      while(true)
      {
          rq->PutMessage(count++);
          std::cout<<"producer : put a message->"<<count<<std::endl;
          count %= 11;
      }
      return nullptr;
  }
  
  int main()
  {
      RingQueue* rq = new RingQueue;
  
      pthread_t c,p;
      pthread_create(&c,nullptr,consumer,rq);
      pthread_create(&p,nullptr,producer,rq);
  
      pthread_join(c,nullptr);
      pthread_join(p,nullptr);
      return 0;
 }

三、线程池

1、什么是线程池？

线程池是一种线程的使用模式。系统、服务器中的线程过多会带来调度开销，进而影响性能。而线程池中维护着多个线程，等待着监督管理者分配可并发执行的任务。避免了处理短时间任务时创建和销毁线程的代价。