头歌实训 第1关：生产者与消费者问题

最新推荐文章于 2025-04-10 16:15:00 发布
最新推荐文章于 2025-04-10 16:15:00 发布
阅读量6.1k 收藏 60
点赞数 23
文章标签： linux ubuntu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_76119663/article/details/130588777
版权

头歌实训 第1关：生产者与消费者问题

任务描述

本关任务：程序 4-1.c 模拟了 1 个生产者和 1 个消费者，请改写该程序，模拟 5 个生产者和 5 个消费者，它们共享一个包含 8 个缓冲区的缓冲池。产品以 4 位编号，最高位表示生产者编号、其他表示该生产者的产品号，参考输出如下：

在这里插入图片描述

知识

  1. 多线程程序如何编译

    输入gcc -pthread XX.c，编译成功后输入./a.out。

  2. pthread_create()函数

    1. 原型int pthread_create(pthread_t *tidp, const pthread_attr_t *attr,(void*)(*start_routine)(void*), void *arg);

      参数的意义（从左往右）：

      • 传递一个 pthread_t 类型的指针变量。
      • 用于手动设置新建线程的属性。一般我们设置成NULL。
      • 以函数指针的方式指明新建线程需要执行的函数，该函数的参数最多有 1 个（可以省略不写），形参和返回值的类型都必须为 void* 类型。
      • 指定传递给 start_routine 函数的实参。

  3. 主线程结束后，子线程会被杀死

    1. 刚刚开始运行的时候发现输入./a.out只输出几行就结束，然后发现应该是主线程结束的时候杀死了子线程。
    2. 使用pthread_join(pthread_t thread, void ** retval)等待

  4. 怎么创建多个线程 😄

    比如说我们这里要创建五个生产者、五个消费者，我们以生产者为例子。1.首先定义pthread_t 类型的指针变量;2.调用for循环创建五个线程，并且在创建线程的pthread_create函数中执行produce函数；3.在创建线程的时候给其编号，也就是通过pthread_create函数里的第四个参数实现。对于这个给线程编号的事，我刚开始想的是用每个线程的id去对应编号，而pthread.h这个头文件里有专门的函数（pthread_self）可以获取线程的id，但是略麻烦、耗空间。这里我们可以直接在创建的时候利用第四个参数给produce函数传一个编号就好了。

    让我们看看代码。这里是只有与我描述的创建过程相关的代码。

     void *produce(void * arg);//这只是一个声明，看看参数是什么样子就可以了
 
 int res[10], i;

  pthread_t t1[8] = {0};


  for (i = 0; i < 5; i++)
  {
    
    res[i] = pthread_create(&(t1[i]), NULL, produce, (void *)&i);
    
    if (res[i] != 0){
      perror("failed to create thread");
      exit(1);
    }
   }

  5. produce、consume怎么实现互斥

    刚刚开始我是用的头文件pthread.h里的pthread_mutex_lock()、pthread_mutex_unlock()做的，但是检测的时候说我信号量的数量不对，所以就改了一下。这个部分没有去看pthread_mutex_lock()、pthread_mutex_unlock()的原型，所以具体怎么错的也不太清楚。但是下面的这种方法是一定可以的。

    sem_t full, empty, mtx, mtx1;//全局变量



//在main函数里面进行初始化
  sem_init(&full, 0, 0);
  sem_init(&mtx, 0, 1);   //produce
  sem_init(&mtx1, 0, 1);  //consume
  sem_init(&empty, 0, N);

奇怪的问题

消费者输出

消费者的输出显示一开始还有别的序号的线程在运行，但是不知道为什么后来就只有序号为4或5的线程在运行了。说实话，不知道这个问题该怎么解决，发现解决方案也是很偶然的。

//有问题的情况的代码
void *consume(void * arg){
  int i;
  for (i = 0; i < PRODUCT_NUM; i++){
    sleep_random(2);

    sem_wait(&full);
    sem_wait(&mtx1);
  
    printf("%d consume: %d\n", (*((int *)arg)), buffer[readpos]);
    buffer[readpos++] =  - 1;
    if (readpos >= N)
      readpos = 0;

    sem_post(&mtx1);
    sem_post(&empty);

  }
}

//能够正常运行的代码

void *consume(void * arg){
  int i;
  int id = *((int *)arg);

  for (i = 0; i < PRODUCT_NUM; i++){
    sleep_random(2);

    sem_wait(&full);
    sem_wait(&mtx1);

    printf("%d consume: %d\n", id, buffer[readpos]);
    buffer[readpos++] =  - 1;
    if (readpos >= N)
      readpos = 0;

    sem_post(&mtx1);
    sem_post(&empty);
    //sem_post(&mtx1);
  }
}

段错误（核心已转移）→也出现了总线错误（核心已转移）

emmm网上搜索一下这个报错就出来了。我是觉得自己写的程序应该是不会出现越界的情况，所以我觉得可能是文中所说的“非关联化空指针”的问题。虽然也不是很懂，但我确实是在使用pthread_join等待子线程结束的时候定义了两个空指针。我把定义的地方注释掉再测试就没有这个报错了。

有关这个报错的博客的网址在此：https://blog.csdn.net/qq_29350001/article/details/53780697

//会报错的代码：
  void * thread_res[10];
  void * thread_res1[10];

  pthread_join(t1[0], thread_res[0]);
  pthread_join(t1[1], thread_res[1]);
  pthread_join(t1[2], thread_res[2]);
  pthread_join(t1[3], thread_res[3]);
  pthread_join(t1[4], thread_res[4]);

  pthread_join(t2[0], thread_res1[0]);
  pthread_join(t2[1], thread_res1[1]);
  pthread_join(t2[2], thread_res1[2]);
  pthread_join(t2[3], thread_res1[3]);
  pthread_join(t2[4], thread_res1[4]);
  
  
 //修改之后的代码
 
 
  // void * thread_res[10];
  // void * thread_res1[10];

  pthread_join(t1[0], NULL);
  pthread_join(t1[1], NULL);
  pthread_join(t1[2], NULL);
  pthread_join(t1[3], NULL);
  pthread_join(t1[4], NULL);

  pthread_join(t2[0], NULL);
  pthread_join(t2[1], NULL);
  pthread_join(t2[2], NULL);
  pthread_join(t2[3], NULL);
  pthread_join(t2[4], NULL);

最终代码

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



#define N  10 
#define PRODUCT_NUM 10
int buffer[N], readpos = 0, writepos = 0;
sem_t full, empty, mtx, mtx1;


void sleep_random(int t) {
  sleep((int)(t * (rand() / (RAND_MAX *1.0))));
}

void *produce(void * arg){
  int id = *((int *)arg);
  int i;
  for (i = 0; i < PRODUCT_NUM; i++){
    sleep_random(2);

    sem_wait(&empty);
     sem_wait(&mtx);

    buffer[writepos++] = id*1000 + i + 1;
    if (writepos >= N)
    {
      writepos = 0;
    }
    printf("produce:    %d\n", id*1000 + i + 1);
 
    sem_post(&mtx);
    sem_post(&full);
  }
}

void *consume(void * arg){
  int i;
  int id = *((int *)arg);

  for (i = 0; i < PRODUCT_NUM; i++){
    sleep_random(2);

    sem_wait(&full);
    sem_wait(&mtx1);
  
    printf("%d consume: %d\n", id, buffer[readpos]);
    buffer[readpos++] =  - 1;
    if (readpos >= N)
      readpos = 0;
      
    sem_post(&mtx1);
    sem_post(&empty);

  }
}

int main(){
  int res[10], res1[10], i;

  pthread_t t1[8] = {0};
  pthread_t t2[8] = {0};

  for (i = 0; i < N; i++)
    buffer[i] =  - 1;
  srand((int)time(0));

  sem_init(&full, 0, 0);
  sem_init(&mtx, 0, 1);
  sem_init(&mtx1, 0, 1);
  sem_init(&empty, 0, N);

  for (i = 0; i < 5; i++)
  {
    
    res[i] = pthread_create(&(t1[i]), NULL, produce, (void *)&i);
    
    if (res[i] != 0){
      perror("failed to create thread");
      exit(1);
    }  
  }
  
  for (int j = 0; j < 5; j++)
  {
    
    res1[j] = pthread_create(&(t2[j]), NULL, consume, (void *)&j);
    if (res1[j] != 0){
      perror("failed to create thread");
      exit(1);
    }
  }

  pthread_join(t1[0], NULL);
  pthread_join(t1[1], NULL);
  pthread_join(t1[2], NULL);
  pthread_join(t1[3], NULL);
  pthread_join(t1[4], NULL);

  pthread_join(t2[0], NULL);
  pthread_join(t2[1], NULL);
  pthread_join(t2[2], NULL);
  pthread_join(t2[3], NULL);
  pthread_join(t2[4], NULL);

  return 0;
}

emm

这个题目还有点bug。缓冲池的大小是10也能过。然后这样写也能过（见下面），虽然这个情况可能不会生成死锁，但是我觉得这样写还是不太好。


void *produce(void * arg){
    //略
    sem_wait(&mtx);
    sem_wait(&empty);
    
    //略
    sem_post(&mtx);
    sem_post(&full);
    
    //略
}
课后作业5：进程的同步与互斥
Junds0的博客
05-21 3188
第1关：生产者与消费者问题 本关任务：程序 4-1.c 模拟了 1 个生产者和 1 个消费者，请改写该程序，模拟 5 个生产者和 5 个消费者，它们共享一个包含 8 个缓冲区的缓冲池。产品以 4 位编号，最高位表示生产者编号、其他表示该生产者的产品号 #include <stdio.h> #include <stdlib.h> #include <time.h> #include <unistd.h> #include <pthread.
生产者消费者问题实践
qq_59969777的博客
08-21 2334
生产者消费者问题实践 进程互斥和同步
头歌实验03：生产者消费者问题实践
ixxoic的博客
10-21 1467
【代码】头歌实验03：生产者消费者问题实践。
生产者消费者问题实践（头歌实验）第1关：生产者消费者问题实践，第2关：进程互斥和同步。
m0_65420451的博客
11-18 6473
生产者消费者问题实践（头歌实验）第1关：生产者消费者问题实践，第2关：进程互斥和同步。1.多线程相关的系统调用，2.使用锁控制进程互斥，3.使用信号量控制进程同步。以上就是今天要讲的内容，本文仅仅简单介绍了生产者消费者问题实践。
课后作业5：进程的同步与互斥 线程（下） 第1关：生产者与消费者问题
最新发布
2401_83240487的博客
04-10 542
课后作业5：进程的同步与互斥 线程（下） 第1关：生产者与消费者问题
Linux线程-生产消费模型和线程池
~
06-09 516
本章主要讲解学习Linux线程章节的后一部分，主要介绍生产消费者模型以及线程池等等的学习
实践Java多线程——生产者消费者问题
m0_46638350的博客
02-03 2428
问题描述 假设仓库中只能存放一件产品，生产者将生产出的产品放入仓库，消费者将仓库的中的产品取走。 仓库中没有产品，生产者将产品放入仓库，否则停止生成并等待，直到仓库中的产品被消费者取走 仓库中存放产品，消费者将产品取出仓库，否则停止消费并等待，直到仓库中再次放入产品 解决办法：管程法 产品 class Product { int id;//产品编号 public Product(int id) { this.id = id; } } 缓存区 //缓冲
生产者与消费者问题
2201_75999403的博客
04-15 467
在Main类中定义了三个内部类，Producer_Customer，Producer，Customer。在Main类中启动两个线程，生产者进程P和消费者进程C。运行时一共3个线程。Producer_Customer用来建造一个缓冲区，生产一把锁，实现一个放入数据和取出数据的方法。Producer用来建造生产者，通过继承Thread类来重写run方法，在run方法中调用成员变量Producer_Customer的类对象p_c 中的put方法来不断输入数据。
头歌实训作业：生产者消费者问题实践
B5201234的博客
11-24 1364
桌上有个能盛的下五个水果的空盘子。爸爸不停的向盘中放苹果或桔子，儿子不停的从盘中取出桔子享用，女儿不停的从盘中取出苹果享用。规定三人不能同时从盘中取放水果。试用信号量实现爸爸、儿子和女儿这三个进程之间的同步。
【操作系统】操作系统精选题（一）(PV经典问题之生产者与消费者）
十二月的猫
06-20 2426
本系列的重点是大学本科课程《操作系统概念》。总结操作系统学习中的各类知识点，并且对各类操作系统试中可能遇到的题型和对应的解法做总结归纳。在自我复习的同时也将这份心得带给大家，希望能对大家的操作系统学习提供帮助~~本文到这里就结束啦~~下节课我们再来进入剩下的三种调度算法操作系统概念（黑宝书）、山东大学高晓程老师PPT及课上讲解、山东大学操作系统往年题、部分考研题。不要私下外传。
进程同步与互斥 生产者与消费者问题--操作系统大作业
12-17
大连理工大学操作系统大作业， 进程同步与互斥 生产者与消费者问题
进程同步实验——生产者与消费者问题算法实现
12-11
进程同步实验——生产者与消费者问题算法实现
生产者与消费者 进程调度模拟（ｃ＋＋）
06-12
这个是很经典的问题 实验题目： 生产者与消费者（综合性实验） 实验环境： C语言编译器 实验内容： ① 由用户指定要产生的进程及其类别，存入进入就绪队列。 　　 ② 调度程序从就绪队列中提取一个就绪进程运行。如果申请的资源被阻塞则进入相应的等待队列，调度程序调度就绪队列中的下一个进程。进程运行结束时，会检查对应的等待队列，激活队列中的进程进入就绪队列。运行结束的进程进入over链表。重复这一过程直至就绪队列为空。 　　 ③ 程序询问是否要继续？如果要转直①开始执行，否则退出程序。 实验目的： 通过实验模拟生产者与消费者之间的关系，了解并掌握他们之间的关系及其原理。由此增加对进程同步的问题的了解。 实验要求： 每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程类型标号、进程系统号、进程状态、进程产品（字符）、进程链指针等等。 系统开辟了一个缓冲区，大小由buffersize指定。 程序中有三个链队列，一个链表。一个就绪队列（ready），两个等待队列：生产者等待队列（producer）；消费者队列（consumer）。一个链表（over），用于收集已经运行结束的进程 本程序通过函数模拟信号量的操作。 参考书目： 1）徐甲同等编，计算机操作系统教程，西安电子科技大学出版社 2）Andrew S. Tanenbaum著，陈向群，马红兵译. 现代操作系统（第2版）. 机械工业出版社 3）Abranham Silberschatz, Peter Baer Galvin, Greg Gagne著. 郑扣根译. 操作系统概念（第2版）. 高等教育出版社 4）张尧学编著. 计算机操作系统教程（第2版）习题解答与实验指导. 清华大学出版社 实验报告要求： （1） 每位同学交一份电子版本的实验报告，上传到202.204.125.21服务器中。 （2） 文件名格式为班级、学号加上个人姓名，例如： 电子04-1-040824101**.doc　　 表示电子04-1班学号为040824101号的**同学的实验报告。 （3） 实验报告内容的开始处要列出实验的目的，实验环境、实验内容等的说明，报告中要附上程序代码，并对实验过程进行说明。 基本数据结构： PCB* readyhead=NULL, * readytail=NULL; // 就绪队列 PCB* consumerhead=NULL, * consumertail=NULL; // 消费者队列 PCB* producerhead=NULL, * producertail=NULL; // 生产者队列 over=(PCB*)malloc(sizeof(PCB)); // over链表 int productnum=0; //产品数量 int full=0, empty=buffersize; // semaphore char buffer[buffersize]; // 缓冲区 int bufferpoint=0; // 缓冲区指针 struct pcb { /* 定义进程控制块PCB */ int flag; // flag=1 denote producer; flag=2 denote consumer; int numlabel; char product; char state; struct pcb * processlink; …… }; processproc( )--- 给PCB分配内存。产生相应的的进程：输入1为生产者进程；输入2为消费者进程，并把这些进程放入就绪队列中。 waitempty( )--- 如果缓冲区满，该进程进入生产者等待队列；linkqueue(exe,&producertail); // 把就绪队列里的进程放入生产者队列的尾部 void signalempty() bool waitfull() void signalfull() void producerrun() void comsuerrun() void main() { processproc(); element=hasElement(readyhead); while(element){ exe=getq(readyhead,&readytail); printf("进程%d申请运行，它是一个",exe->numlabel); exe->flag==1? printf("生产者\n"):printf("消费者\n"); if(exe->flag==1) producerrun(); else comsuerrun(); element=hasElement(readyhead); } printf("就绪队列没有进程\n"); if(hasElement(consumerhead)) { printf("消费者等待队列中有进程:\n"); display(consumerhead); } else { printf("消费者等待队列中没有进程\n"); } if(hasElement(producerhead)) { printf("生产者等待队列中有进程:\n"); display(producerhead); } else { printf("生产者等待队列中没有进程\n"); } }
江西专版2019中考生物第1部分第一单元第一章第二章复习真题模拟实训
08-06
14. **食物链中的有毒物质积累**：图示中，丙的有毒物质含量最高，说明其位于食物链顶端，是顶级消费者，故甲可能是生产者，乙可能是初级消费者，丁可能因甲数量增多而短期内减少。 15. **探究实验设计**：探究...
操作系统实训复习笔记（第7关：生产者消费者问题实践）
岁岁岁平安的博客
06-25 851
本篇博客的主要内容就是作者本人期末操作系统实训的复习的笔记。包括：第1关：生产者消费者问题实践第2关：进程互斥和同步的详细讲解。
os实训课程模拟考试（大题复习）
岁岁岁平安的博客
06-29 1482
本篇博客是作者关于期末《操作系统实训》的大题复习和总结。包括：5、Linux操作系统。6、Linux之进程管理一。7、生产者消费者问题实践。8、基于信号量的进程间通信。9、基于命名管道与信号的进程间通信。10、Linux vi/vim编辑器。11、读文件系统函数。12、写文件系统函数。13、进程基础操作。
生产者与消费者经典算法——Java，操作系统实验实现
m0_52421130的博客
06-10 869
生产者和消费者这样一个经典的进程同步问题的运行逻辑结构。生产者和消费者问题要求我们设计在同一个进程地址空间内执行的两个线程，生产者生成产品放入缓冲区供消费者消费，当消费者从缓冲区获取产品后，释放缓冲区；当生产者在生产产品时没有缓冲区空间可用，那么生产者必须等待消费者消费产品释放一个缓冲区。...
头歌实践教学平台 大数据编程 实训答案（三）
qq_63961628的博客
10-08 5360
MapReduce是一种可用于数据处理的编程模型，我们现在设想一个场景，你接到一个任务，任务是：挖掘分析我国气象中心近年来的数据日志，该数据日志大小有3T,让你分析计算出每一年的最高气温，如果你现在只有一台计算机，如何处理呢？我想你应该会读取这些数据，并且将读取到的数据与目前的最大气温值进行比较。比较完所有的数据之后就可以得出最高气温了。不过以我们的经验都知道要处理这么多数据肯定是非常耗时的。如果我现在给你三台机器，你会如何处理呢？
程序 main.c 模拟了 1 个生产者和 1 个消费者，请改写该程序，模拟 5 个生产者和 5 个消费者，它们共享一个包含 8 个缓冲区的缓冲池。
11-02
在C语言中，要模拟5个生产者和5个消费者共享8个缓冲区的场景，你可以使用信号量（semaphores）来控制对缓冲区的访问以及同步生产者和消费者的操作。这里提供了一个简化的示例，假设我们已经包含了必要的头文件，并定义了sem_t类型的信号量数组： ```c #include <stdio.h> #include <stdlib.h> #include <semaphore.h> // 包含信号量库 #define BUFFER_COUNT 8 #define MAX_PRODUCERS 5 #define MAX_CONSUMERS 5 #define SEMAPHORE_BUFFER_AVAIL 0 #define SEMAPHORE_BUFFER_TAKEN 1 typedef struct { int buffer[BUFFER_COUNT]; sem_t producer_semaphore; // 生产者信号量 sem_t consumer_semaphore; // 消费者信号量 } BufferPool; void producer(BufferPool* pool, int id) { sem_wait(&pool->producer_semaphore); // 等待可用缓冲区 pool->buffer[id] = produce_data(); // 生产数据并更新缓冲区 printf("Producer %d produced data and placed in buffer %d\n", id, id); sem_post(&pool->consumer_semaphore); // 释放消费者信号量 } void consumer(BufferPool* pool, int id) { sem_wait(&pool->consumer_semaphore); // 等待有消费者需要的数据 if (pool->buffer[id] != -1) { consume(pool->buffer[id]); // 消耗数据 pool->buffer[id] = -1; // 标记已消费 printf("Consumer %d consumed from buffer %d\n", id, id); } sem_post(&pool->producer_semaphore); // 通知生产者有空位 } int main() { BufferPool pool; sem_init(&pool.producer_semaphore, 0, BUFFER_COUNT); // 初始化生产者信号量 sem_init(&pool.consumer_semaphore, 0, 0); // 初始化消费者信号量 for (int i = 0; i < MAX_PRODUCERS; ++i) { // 创建生产者线程 pthread_t producer_thread; pthread_create(&producer_thread, NULL, producer, &pool, i); } for (int i = 0; i < MAX_CONSUMERS; ++i) { // 创建消费者线程 pthread_t consumer_thread; pthread_create(&consumer_thread, NULL, consumer, &pool, i); } // 等待所有线程完成 for (int i = 0; i < MAX_PRODUCERS + MAX_CONSUMERS; ++i) { pthread_join(producer_threads[i], NULL); } sem_destroy(&pool.producer_semaphore); sem_destroy(&pool.consumer_semaphore); return 0; } ``` 在这个例子中，生产者会等待消费者占用的缓冲区减少到一定的数量（等于缓冲区总数），然后才放入新的数据；而消费者会等待有新产生的数据可供消耗。这只是一个基础的框架，实际应用中可能还需要处理更多细节，如线程安全、错误处理等。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值