生产者消费者

已于 2023-11-14 10:24:15 修改
阅读量132 收藏
点赞数 1
分类专栏： # 计算机操作系统 文章标签： c++
于 2023-11-14 10:22:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60415234/article/details/134393105
版权
  • 实验内容

1.编写一个简单的进程调度器，要求：

  1. （1）实现基于优先级的抢占式调度算法。
  2. （2）程序中需要包含进程创建、进程调度、进程结束等功能函数。
  3. （3）能够实现多个进程的并发执行，能够正确处理进程的状态转换

2.编写一个生产者-消费者模型，其中生产者和消费者共享一个缓冲区。生产者不断产生物品并把它们放入缓冲区，消费者不断从缓冲区中取出物品。当缓冲区为空时，消费者等待生产者；当缓冲区已满时，生产者等待消费者。要求：

（1）缓冲区大小为10；

（2）合理地使用信号量，保证生产者和消费者之间的正确交互，解决资源竞争和数据不一致的问题。当一个进程需要等待另一个进程完成某个操作时，使用信号量来实现进程同步；

  •  代码实现（要求对代码作相应的注释）
  1. 进程调度器

#include <stdio.h>

#include <stdlib.h>

#define MAX_PROCESSES 10

typedef struct {

    int pid;        // 进程ID

    int priority;   // 优先级

    int burst_time; // 执行时间

    int remaining_time; // 剩余执行时间

    int status;     // 进程状态：0表示就绪，1表示运行，2表示结束

} Process;

Process processes[MAX_PROCESSES];

int num_processes = 0;

// 创建进程

void createProcess(int priority, int burst_time) {

    if (num_processes >= MAX_PROCESSES) {

        printf("无法创建更多进程。\n");

        return;

    }

    

    Process new_process;

    new_process.pid = num_processes + 1;

    new_process.priority = priority;

    new_process.burst_time = burst_time;

    new_process.remaining_time = burst_time;

    new_process.status = 0;

    

    processes[num_processes] = new_process;

    num_processes++;

}

// 进程调度

void schedule() {

    int i, highest_priority = -1, highest_priority_index = -1;

    

    // 找到优先级最高的就绪进程

    for (i = 0; i < num_processes; i++) {

        if (processes[i].status == 0 && processes[i].priority > highest_priority) {

            highest_priority = processes[i].priority;

            highest_priority_index = i;

        }

    }

    

    // 更新进程状态

    for (i = 0; i < num_processes; i++) {

        if (i == highest_priority_index) {

            processes[i].status = 1; // 设置为运行状态

        } else if (processes[i].status == 1) {

            processes[i].status = 0; // 设置为就绪状态

        }

    }

}

// 进程结束

void endProcess(int pid) {

    int i;

    

    // 找到对应进程并设置为结束状态

    for (i = 0; i < num_processes; i++) {

        if (processes[i].pid == pid) {

            processes[i].status = 2;

            break;

        }

    }

}

// 打印进程信息

void printProcesses() {

    int i;

    

    printf("进程信息：\n");

    printf("PID\t优先级\t执行时间\t剩余时间\t状态\n");

    

    for (i = 0; i < num_processes; i++) {

        printf("%d\t%d\t%d\t\t%d\t\t", processes[i].pid, processes[i].priority, processes[i].burst_time, processes[i].remaining_time);

        

        if (processes[i].status == 0) {

            printf("就绪\n");

        } else if (processes[i].status == 1) {

            printf("运行\n");

        } else if (processes[i].status == 2) {

            printf("结束\n");

        }

    }

}

int main() {

    createProcess(2, 5);

    createProcess(1, 3);

    createProcess(3, 2);

    

    printProcesses();

    

    schedule();

    printProcesses();

    

    endProcess(2);

    printProcesses();

    

    return 0;

}

  1. 生产者-消费者模型

//一直生产消费的生产者-消费者模型

#include <stdio.h>

#include <stdlib.h>

#include <Windows.h>

#define BUFFER_SIZE 10

#define NUM_PRODUCERS 2

#define NUM_CONSUMERS 2

int buffer[BUFFER_SIZE];

int in = 0;

int out = 0;

HANDLE empty;   // 空槽位的信号量

HANDLE full;    // 已占用槽位的信号量

HANDLE mutex;   // 互斥信号量，用于保护缓冲区的访问

DWORD WINAPI producer(LPVOID arg) {

    int item;

    

    while (1) {

        item = rand() % 100; // 产生一个随机物品

        

        WaitForSingleObject(empty, INFINITE); // 等待空槽位

        

        WaitForSingleObject(mutex, INFINITE); // 互斥访问缓冲区

        buffer[in] = item; // 将物品放入缓冲区

        in = (in + 1) % BUFFER_SIZE;

        ReleaseMutex(mutex);

        

        ReleaseSemaphore(full, 1, NULL); // 增加已占用槽位的信号量

        

        printf("生产者 %d 生产了物品 %d\n", *((int *)arg), item);

        

        Sleep(rand() % 3000); // 随机休眠一段时间

    }

    

    return 0;

}

DWORD WINAPI consumer(LPVOID arg) {

    int item;

    

    while (1) {

        WaitForSingleObject(full, INFINITE); // 等待已占用槽位

        

        WaitForSingleObject(mutex, INFINITE); // 互斥访问缓冲区

        item = buffer[out]; // 从缓冲区取出物品

        out = (out + 1) % BUFFER_SIZE;

        ReleaseMutex(mutex);

        

        ReleaseSemaphore(empty, 1, NULL); // 增加空槽位的信号量

        

        printf("消费者 %d 消费了物品 %d\n", *((int *)arg), item);

        

        Sleep(rand() % 3000); // 随机休眠一段时间

    }

    

    return 0;

}

int main() {

    int i;

    HANDLE producers[NUM_PRODUCERS];

    HANDLE consumers[NUM_CONSUMERS];

    int producer_ids[NUM_PRODUCERS];

    int consumer_ids[NUM_CONSUMERS];

    

    // 初始化信号量

    empty = CreateSemaphore(NULL, BUFFER_SIZE, BUFFER_SIZE, NULL);

    full = CreateSemaphore(NULL, 0, BUFFER_SIZE, NULL);

    mutex = CreateMutex(NULL, FALSE, NULL);

    

    // 创建生产者线程

    for (i = 0; i < NUM_PRODUCERS; i++) {

        producer_ids[i] = i + 1;

        producers[i] = CreateThread(NULL, 0, producer, (LPVOID)&producer_ids[i], 0, NULL);

    }

    

    // 创建消费者线程

    for (i = 0; i < NUM_CONSUMERS; i++) {

        consumer_ids[i] = i + 1;

        consumers[i] = CreateThread(NULL, 0, consumer, (LPVOID)&consumer_ids[i], 0, NULL);

    }

    

    // 等待生产者线程结束

    WaitForMultipleObjects(NUM_PRODUCERS, producers, TRUE, INFINITE);

    

    // 等待消费者线程结束

    WaitForMultipleObjects(NUM_CONSUMERS, consumers, TRUE, INFINITE);

    

    // 关闭句柄

    CloseHandle(empty);

    CloseHandle(full);

    CloseHandle(mutex);

    

    return 0;

}

//加了停止条件的生产者-消费者模型

#include <stdio.h>

#include <stdlib.h>

#include <windows.h>

#define BUFFER_SIZE 10

#define NUM_PRODUCERS 2

#define NUM_CONSUMERS 2

int buffer[BUFFER_SIZE];

int in = 0;

int out = 0;

int stop = 0;

HANDLE mutex;

HANDLE empty;

HANDLE full;

DWORD WINAPI producer(LPVOID arg) {

    int item;

    while (!stop) {

        item = rand() % 100; // 产生一个随机物品

        

        WaitForSingleObject(empty, INFINITE);

        WaitForSingleObject(mutex, INFINITE);

        

        buffer[in] = item; // 将物品放入缓冲区

        in = (in + 1) % BUFFER_SIZE;

        

        ReleaseMutex(mutex);

        ReleaseSemaphore(full, 1, NULL);

        

        printf("生产者 %d 生产了物品 %d\n", *((int*)arg), item);

        Sleep((rand() % 3) * 1000); // 随机休眠一段时间

    }

    

    return 0;

}

DWORD WINAPI consumer(LPVOID arg) {

    int item;

    while (!stop) {

        WaitForSingleObject(full, INFINITE);

        WaitForSingleObject(mutex, INFINITE);

        

        item = buffer[out]; // 从缓冲区取出物品

        out = (out + 1) % BUFFER_SIZE;

        

        ReleaseMutex(mutex);

        ReleaseSemaphore(empty, 1, NULL);

        

        printf("消费者 %d 消费了物品 %d\n", *((int*)arg), item);

        Sleep((rand() % 3) * 1000); // 随机休眠一段时间

    }

    

    return 0;

}

int main() {

    HANDLE producers[NUM_PRODUCERS];

    HANDLE consumers[NUM_CONSUMERS];

    int producer_ids[NUM_PRODUCERS];

    int consumer_ids[NUM_CONSUMERS];

    

    mutex = CreateMutex(NULL, FALSE, NULL);

    empty = CreateSemaphore(NULL, BUFFER_SIZE, BUFFER_SIZE, NULL);

    full = CreateSemaphore(NULL, 0, BUFFER_SIZE, NULL);

    

    // 创建生产者线程

    for (int i = 0; i < NUM_PRODUCERS; i++) {

        producer_ids[i] = i + 1;

        producers[i] = CreateThread(NULL, 0, producer, &producer_ids[i], 0, NULL);

    }

    

    // 创建消费者线程

    for ( i = 0; i < NUM_CONSUMERS; i++) {

        consumer_ids[i] = i + 1;

        consumers[i] = CreateThread(NULL, 0, consumer, &consumer_ids[i], 0, NULL);

    }

    

    // 运行一段时间后停止生产者和消费者

    Sleep(10 * 1000);

    stop = 1;

    

    // 等待生产者线程结束

    WaitForMultipleObjects(NUM_PRODUCERS, producers, TRUE, INFINITE);

    

    // 等待消费者线程结束

    WaitForMultipleObjects(NUM_CONSUMERS, consumers, TRUE, INFINITE);

    

    CloseHandle(mutex);

    CloseHandle(empty);

    CloseHandle(full);

    

    return 0;

}

旷野的风》endl
关注
专栏目录
生产者消费者模型
GG_Bruse的博客
02-15 7900
对应到生产者消费者模型中，函数传参实际上就是生产者生产的过程，而执行函数体实际上就是消费者消费的过程，但生产者只负责生产数据，消费者只负责消费数据，在消费者消费期间生产者可以同时进行生产，因此生产者消费者模型本质是一种松耦合。消费者也不用找生产者索要数据，而是直接从这个容器中取数据。虽然消费者消费的快，但开始时阻塞队列中是没有数据的，因此消费者只能在empty条件变量下等待，直到生产者生产完一个数据后，消费者才会被唤醒进而进行消费，消费者消费完这一个数据后又会进行等待，因此生产者和消费者的步调就是一致的。
多进程-生产者,消费者问题
weixin_44128687的博客
02-15 2452
进程同步经典问题-生产者消费者 生产者消费者模型描述： 生产者/消费者问题可以描述为：两个或者更多的进程（线程）共享同一个缓冲区，其中一个或多个进程（线程）作为“生产者”会不断地向缓冲区中添加数据，另一个或者多个进程（线程）作为“消费者”从缓冲区中取走数据。生产者/消费者模型的关注点为： 1、生产者和消费者必须互斥的使用缓冲区 2.缓冲区空时，消费者不能读取数据 3.缓冲区满时，生产者不能添加数据...
三种方式实现生产者-消费者模型
Sicimike的博客
11-17 4265
前言 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该...
Linux下生产者消费者问题的C语言实现
Yuhan2001的CSDN博客
12-05 8749
操作系统的课程实验，在Linux下生产者-消费者问题的C语言实现。
信号量解决生产者，消费者问题
小黄人
04-22 785
#include <windows.h> #include <process.h> #include <iostream> #define BUFFER_SIZE 10 #define MAXNUM 3 using namespace std; int buffer[BUFFER_SIZE]; int r_count = 0; int w_count = 0;CRITICAL_SECTION
生产者消费者问题
holyshit666的博客
09-16 418
生产者/消费者问题是并发处理中遇到的最常见的问题，通常可描述如下：有一个或多个生产者生产某种类型的数据（记录，字符），并放置在缓冲区中；有一个消费者从缓冲区中取数据，每次取一项；系统保证避免对缓冲区的重复操作，也就是说，在任何时候只有一个主体（生产者或消费者）可以访问缓冲区。问题是要确保这样的情况，当缓冲区已满时，生产者不会继续向其中添加数据；当缓冲区为空时，消费者不会从中移走数据。 假设缓冲区
生产者消费者模型详解
小赵小赵福星高照的博客
04-06 9150
生产者消费者模型 文章目录生产者消费者模型什么是生产者消费者模型基于BlockingQueue的生产者消费者模型单生产者单消费者模型多生产者多消费者模型 什么是生产者消费者模型 生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者
Java实现生产者消费者问题
无简介
04-26 4905
生产者-消费者问题是计算机科学中经典的同步问题之一，它描述了多个线程在共享数据的情况下如何协同工作。该问题通常涉及到一个共享缓冲区，其中生产者线程生成数据并将其放入缓冲区，而消费者线程从缓冲区中取出数据并对其进行处理。生产者和消费者线程必须协同工作，以避免竞态条件和死锁等问题。以上为通过Java代码实现解决生产消费者问题的实例，通过本实例希望大家能学会如果解决此问题，学会如何数据共享时，各个线程协同工作。
Linux生产者消费者模型
2021dragon的博客
02-27 9140
文章目录生产者消费者模型为何要使用生产者消费者模型生产者消费者模型优点基于BlockingQueue的生产者消费者模型C++queue模拟阻塞队列的生产消费模型POSIX信号量POSIX信号量函数基于环形队列的生产消费模型 生产者消费者模型 为何要使用生产者消费者模型 生产者消费者模型优点 基于BlockingQueue的生产者消费者模型 C++queue模拟阻塞队列的生产消费模型 POSIX信号量 POSIX信号量函数 基于环形队列的生产消费模型 ...
生产者消费者算法的实现
jihome的博客
03-30 7805
操作系统中典型的生产者消费者算法的实现。
理解生产者消费者模型及在Python编程中的运用实例
12-25
什么是生产者消费者模型 在 工作中，大家可能会碰到这样一种情况：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产 生数据的模块，就形象地称为...
C语言实现生产者消费者问题
05-27
C语言实现生产者消费者问题，分配具有n个缓冲区的缓冲池，作为共享资源。 定义两个资源型信号量empty 和full，empty信号量表示当前空的缓冲区数量，full表示当前满的缓冲区数量。 定义互斥信号量mutex，当某个进程...
Java实现简易生产者消费者模型过程解析
08-19
Java实现简易生产者消费者模型过程解析 一、概述 生产者消费者模型是一种常见的并发编程模型，在Java中可以通过使用同步机制和wait/notify机制来实现。在本文中，我们将通过一个简单的示例代码介绍Java实现简易...
Qt入门练习项目——生产者消费者模型.zip
08-01
**Qt入门练习项目——生产者消费者模型** 在编程领域，生产者消费者模型是一种常见的多线程同步问题的解决方案。这个模型通常用于处理数据流的异步处理，其中一个或多个线程（生产者）生成数据，而其他线程（消费者...
java解决单缓冲生产者消费者问题示例
09-04
在Java编程中，生产者消费者问题是多线程同步的一个经典示例，用于演示如何在多个线程之间共享有限资源。本示例展示了如何解决单缓冲区的生产者消费者问题，即只有一个存储单元供生产者和消费者共享。这个问题的核心...
【C++ 面试 - 新特性】每日 3 题（九）
Newin2020的博客
09-10 667
✍个人博客：Pandaconda-CSDN博客📣专栏地址：http://t.csdnimg.cn/fYaBd📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~
【C++】创建静态数组，动态数组，vector数组
分享计算机视觉，C++，网络摄像头研发，音视频开发，嵌入式等知识。
09-11 218
vector可以动态地增长和缩小，并且不需要手动管理内存。注意，对于动态数组，你需要手动管理内存（分配和释放）。使用delete[]来释放动态分配的数组，而不是单个的delete。vector是C++中管理动态数组的首选方式，因为它提供了比原始数组更多的功能和灵活性，同时隐藏了内存管理的复杂性。C++也支持动态数组，其大小在运行时确定，并使用new关键字分配内存，使用delete关键字释放内存。如果你没有初始化数组中的所有元素，那么那些未初始化的元素会被自动初始化为0（对于内置类型如int）。
C++与QML的数据交互
最新发布
qq_50679120的博客
09-11 461
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 234
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
Java生产者消费者模式实现详解
"Java生产者消费者模式的多种实现方法，包括使用synchronized和Object的wait、notifyAll方法，以及使用BlockingQueue。" 在Java中，生产者消费者模式是一种多线程设计模式，用于解决线程间的数据共享和同步问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值