用队列实现生产者-消费者模型 —— 详解与代码讲解

最新推荐文章于 2025-09-23 21:52:06 发布
原创 最新推荐文章于 2025-09-23 21:52:06 发布 · 883 阅读 · 20 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C #操作系统

该文章已生成可运行项目，

用队列实现生产者-消费者模型 —— 详解与代码讲解

一、引言

生产者-消费者问题（Producer-Consumer Problem）是操作系统、并发编程和数据结构课程中的经典案例。它描述了两个角色：生产者负责生产数据并放入缓冲区，消费者则从缓冲区取出数据进行消费。两者通过一个共享的缓冲区（通常为队列）进行协作，既要保证数据的正确流转，又要避免资源竞争和数据丢失。

本篇文章将以循环队列为核心，详细讲解如何用 C 语言实现一个简洁、易懂的生产者-消费者模型。本文适合数据结构初学者和对并发编程感兴趣的读者。

二、生产者-消费者问题的基本思想

1. 问题描述

  • 生产者不断产生产品，放入缓冲区。
  • 消费者不断从缓冲区取出产品进行消费。
  • 缓冲区有容量限制，满时生产者需等待，空时消费者需等待。

2. 解决思路

  • 用一个队列作为缓冲区，保证产品先进先出（FIFO）。
  • 生产者在队列未满时入队，消费者在队列非空时出队。
  • 用队列的计数器和指针管理队列状态。

三、循环队列的数据结构设计

1. 队列结构体定义

循环队列是一种高效利用数组空间的队列实现方式。其结构体如下：

#define QUEUE_MAX_SIZE 10

typedef struct
{
    int data[QUEUE_MAX_SIZE]; // 存储产品的数组
    int front;                // 队头指针，指向下一个要被消费的元素
    int rear;                 // 队尾指针，指向下一个要被生产的位置
    int count;                // 当前队列元素个数
} Queue;
字段说明
  • data：用于存储产品（这里用整数模拟产品）。
  • front：队头指针，指向下一个要被消费的元素。
  • rear：队尾指针，指向下一个要被生产的位置。
  • count：当前队列中的产品数量。

2. 队列操作函数声明

void queue_init(Queue *q);
int queue_is_empty(Queue *q);
int queue_is_full(Queue *q);
int queue_enqueue(Queue *q, int item);
int queue_dequeue(Queue *q, int *item);
void queue_print(Queue *q);

四、队列操作函数实现

1. 初始化队列

void queue_init(Queue *q)
{
    q->front = 0;
    q->rear = 0;
    q->count = 0;
}

2. 判断队列是否为空

int queue_is_empty(Queue *q)
{
    return q->count == 0;
}

3. 判断队列是否已满

int queue_is_full(Queue *q)
{
    return q->count == QUEUE_MAX_SIZE;
}

4. 入队操作（生产者调用）

int queue_enqueue(Queue *q, int item)
{
    if (queue_is_full(q))
        return 0;
    q->data[q->rear] = item;
    q->rear = (q->rear + 1) % QUEUE_MAX_SIZE;
    q->count++;
    return 1;
}

5. 出队操作（消费者调用）

int queue_dequeue(Queue *q, int *item)
{
    if (queue_is_empty(q))
        return 0;
    *item = q->data[q->front];
    q->front = (q->front + 1) % QUEUE_MAX_SIZE;
    q->count--;
    return 1;
}

6. 打印队列内容

void queue_print(Queue *q)
{
    printf("Queue: [");
    for (int i = 0, idx = q->front; i < q->count; i++, idx = (idx + 1) % QUEUE_MAX_SIZE)
    {
        printf("%d ", q->data[idx]);
    }
    printf("] (count=%d)\n", q->count);
}

五、生产者与消费者函数实现

1. 生产者函数

void producer(Queue *q)
{
    if (queue_is_full(q))
    {
        printf("Queue is full, cannot produce.\n");
        return;
    }
    int data = rand() % 100; // 生成一个随机数作为产品
    queue_enqueue(q, data);
    printf("Produced: %d\n", data);
}
  • 首先判断队列是否已满，满则不能生产。
  • 随机生成一个产品并入队。

2. 消费者函数

void consumer(Queue *q)
{
    if (queue_is_empty(q))
    {
        printf("Queue is empty, cannot consume.\n");
        return;
    }
    int data;
    queue_dequeue(q, &data);
    printf("Consumed: %d\n", data);
}
  • 首先判断队列是否为空，空则不能消费。
  • 从队列中取出产品并打印。

六、主函数与交互流程

主函数通过命令行交互，模拟生产和消费过程：

int main(void)
{
    Queue q;
    queue_init(&q);

    char cmd;
    printf("Simple Producer-Consumer Simulation (Queue Version)\n");
    printf("p: produce, c: consume, q: quit\n");
    while (1)
    {
        queue_print(&q);
        printf("Enter command (p/c/q): ");
        scanf(" %c", &cmd);
        if (cmd == 'p')
        {
            producer(&q);
        }
        else if (cmd == 'c')
        {
            consumer(&q);
        }
        else if (cmd == 'q')
        {
            break;
        }
        else
        {
            printf("Invalid command.\n");
        }
    }
    return 0;
}
  • 用户输入 p 生产产品，c 消费产品，q 退出程序。
  • 每次操作后都会打印当前队列状态，便于观察缓冲区变化。

七、完整代码

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

#define QUEUE_MAX_SIZE 10

typedef struct
{
    int data[QUEUE_MAX_SIZE];
    int front;
    int rear;
    int count;
} Queue;

void queue_init(Queue *q)
{
    q->front = 0;
    q->rear = 0;
    q->count = 0;
}

int queue_is_empty(Queue *q)
{
    return q->count == 0;
}

int queue_is_full(Queue *q)
{
    return q->count == QUEUE_MAX_SIZE;
}

int queue_enqueue(Queue *q, int item)
{
    if (queue_is_full(q))
        return 0;
    q->data[q->rear] = item;
    q->rear = (q->rear + 1) % QUEUE_MAX_SIZE;
    q->count++;
    return 1;
}

int queue_dequeue(Queue *q, int *item)
{
    if (queue_is_empty(q))
        return 0;
    *item = q->data[q->front];
    q->front = (q->front + 1) % QUEUE_MAX_SIZE;
    q->count--;
    return 1;
}

void queue_print(Queue *q)
{
    printf("Queue: [");
    for (int i = 0, idx = q->front; i < q->count; i++, idx = (idx + 1) % QUEUE_MAX_SIZE)
    {
        printf("%d ", q->data[idx]);
    }
    printf("] (count=%d)\n", q->count);
}

void producer(Queue *q)
{
    if (queue_is_full(q))
    {
        printf("Queue is full, cannot produce.\n");
        return;
    }
    int data = rand() % 100; // 生成一个随机数作为产品
    queue_enqueue(q, data);
    printf("Produced: %d\n", data);
}

void consumer(Queue *q)
{
    if (queue_is_empty(q))
    {
        printf("Queue is empty, cannot consume.\n");
        return;
    }
    int data;
    queue_dequeue(q, &data);
    printf("Consumed: %d\n", data);
}

int main(void)
{
    Queue q;
    queue_init(&q);

    char cmd;
    printf("Simple Producer-Consumer Simulation (Queue Version)\n");
    printf("p: produce, c: consume, q: quit\n");
    while (1)
    {
        queue_print(&q);
        printf("Enter command (p/c/q): ");
        scanf(" %c", &cmd);
        if (cmd == 'p')
        {
            producer(&q);
        }
        else if (cmd == 'c')
        {
            consumer(&q);
        }
        else if (cmd == 'q')
        {
            break;
        }
        else
        {
            printf("Invalid command.\n");
        }
    }
    return 0;
}

八、运行方法

1. 保存代码

将上述代码保存为 produce_consumer.c 文件。

2. 编译与运行

Windows 下
gcc produce_consumer.c -o produce_consumer
produce_consumer.exe
Linux/macOS 下
gcc produce_consumer.c -o produce_consumer
./produce_consumer

3. 交互示例

Simple Producer-Consumer Simulation (Queue Version)
p: produce, c: consume, q: quit
Queue: [] (count=0)
Enter command (p/c/q): p
Produced: 42
Queue: [42 ] (count=1)
Enter command (p/c/q): p
Produced: 17
Queue: [42 17 ] (count=2)
Enter command (p/c/q): c
Consumed: 42
Queue: [17 ] (count=1)
Enter command (p/c/q): q

九、模型分析与扩展

1. 队列的优势

  • 先进先出（FIFO）：保证产品按生产顺序被消费。
  • 空间复用：循环队列充分利用数组空间，避免“假溢出”。
  • 易于扩展：可方便地扩展为多线程并发模型。

2. 适用场景

  • 单线程模拟生产者-消费者问题。
  • 数据流缓冲、任务调度等需要先进先出特性的场景。

3. 多线程扩展建议

  • 若要实现多线程并发，需要引入互斥锁（mutex）和条件变量（condition variable）等同步机制，防止竞态条件和数据不一致。
  • 可参考 pthread 库的相关用法。

十、总结

本文详细介绍了如何用循环队列实现生产者-消费者模型，涵盖了队列的定义、操作函数、生产者与消费者实现、主函数交互流程以及完整代码和运行方法。通过本例，你可以深入理解队列数据结构的实际应用，以及生产者-消费者问题的基本思想。

如需进一步学习多线程并发、信号量等高级内容，欢迎继续关注相关专题！

本文章已经生成可运行项目
来用C语言实写一个生产者消费者模型吧！！
Wensxiao的博客
06-04 470
#include <cstdlib> #include <cstdio> #include <pthread.h> #include <cstring> #include <ctime> #include <sys/time.h> #define PRODUCTS_MAX 150 #define PRODUCER_MAX 20 #define CONSUMER_MAX 10 #define LOAD 500 #define WO.
【基础篇-消息队列】——详解 RocketMQ 和 Kafka 的消息模型
小志的博客
06-23 998
本文通过示例详细解析了RocketMQ和Kafka的消息模型。以一个包含5个队列、分布在2个Broker上的MyTopic主题为例，说明生产者可以自由选择队列发送消息。重点讲解了消费组机制：不同消费组相互独立，同一消费组内每个队列只能由一个消费者实例占用，但消费者与消费位置无关。消费位置由服务端维护，记录各队列的消费进度。文章还通过表格直观展示了消费位置的管理方式，帮助读者深入理解消息队列的核心概念和运行机制。
LinuxC语言实现生产者和消费者模型
08-30
LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型
生产者-消费者模型详解
最新发布
jakelihua
09-23 726
这篇文章详细介绍了生产者-消费者模型的实现方法，主要包含以下内容： 模型概述：生产者生成数据存入共享区域，消费者取出处理，通过同步机制协调两者。 具体实例：实现一个基于共享变量x的生产者-消费者模型，x初始为0，生产者当x=0或x%3≠0时加2，消费者当x≠0且x%3=0时减1，x>20时所有协程退出。 两种实现方式： 基础版：使用单个条件变量协调生产和消费 优化版：使用两个独立的条件变量分别管理生产者和消费者队列 关键技术点： 互斥锁保护共享变量 条件变量实现等待/通知机制 WaitGroup跟踪协
C语言实现操作系统中生产者消费者
06-26
用C-Free5软件写的，主函数为Int类型。在其他软件上可能要改成void，算法方面没有什么问题。如果要缓冲池满就把生产者M1的数改的比消费者M2的高，要缓冲池空则相反。
生产者消费者模型---详解及代码实现
热门推荐
lvxin15353715790的博客
04-09 5万+
概念 生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。 321原则 三种角色：生产者、消费者、仓库 两种关...
消息队列：生产者/消费者模式
qq_39575279的博客
02-28 2万+
1.什么是生产者消费者模式 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。 这个阻塞队列就是用来给生产者和消费者解耦的。...
Linux——生产者消费者模型
hu_143的博客
08-07 438
Linux——生产者消费者模型详解！！！
Java多线程中的生产者消费者模式详解
多线程-生产者-消费者》深入讲解了如何利用Java中的线程同步与通信机制来实现一个安全、高效的生产者-消费者模式。该知识点不仅涵盖了多线程的基本概念，还涉及了线程间通信的关键方法如`wait()`、`notify()`和`...
Kafka Avro生产者消费者示例项目详解
描述中提到的“样本”、“技术样本示例”进一步说明了项目的定位——它是一组精心设计的技术演示代码，涵盖 Kafka 生产者（Producer）、消费者（Consumer）的基本实现，以及更高级的主题如 Avro 序列化、Schema 验证...
C语言队列实现详解：链队列与顺序队列代码解析
说明作者希望读者能够在掌握基础之后进一步拓展知识面，比如学习双端队列（Deque）、优先队列（Priority Queue）、阻塞队列等高级变种，或者了解队列在多线程编程中的同步机制（如生产者-消费者模型）。 从标签...
生产者和消费者代码
01-09
生产者消费者
生产者消费者模式(队列描述)
question_mark的博客
12-19 292
class MyQueue2 { private int[] date = new int[100]; private int head = 0;//队首元素的下标 private int tail = 0;//队尾元素的下标 //如果head == tail 则队列满了 因为这是个前闭后开区间 private volatile int size = 0;...
C语言实现生产者消费者模型(线程、信号量、互斥锁)
weixin_43030270的博客
11-10 2879
C 线程
生产者与消费者,采用队列方式实现
强强的博客
09-02 449
看,代码 package com.myself; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicI...
生产者——消费者——队列——锁
New__Dream的博客
08-27 572
消费者和生产者模式 一.概念 1.生产者消费者不是设计模式，属于线程之间的经典问题，生产者生产什么消费者消费什么，生产者不生产消费者不能消费 实现代码： 先创建一个产品类 package com.qfedu.test1; /** * 产品类 * @author WHD * */ public class Computer { private String mainFrame; private String screen; private boolean proState;// 默认值为f
C# 实现生产者消费者队列
dayao8092的博客
02-19 705
开发过程中经常会碰到这样的场景：需要从一个地方获取一些数据，然后处理数据并将其保存在数据库中。 1 2 3 4 5 6 7 8 9 10 privatevoidFetchData() {} privatevoidSaveData() {} staticvoidMain(string[] args) { ...
005.生产者消费者队列（翻转队列）
行走
01-13 347
翻转队列 在多线程生产者-消费者模式中生产者线程向队列添加对象，消费者线程从队列取走对象因为涉及到多线程访问，这个队列必须在添加/取走对象时加锁。这个模版实现这种多线程安全的队列，另外使用两个队列翻转的技术，可以极大的减少锁互斥的几率。SwappingListEx 对SwappingList进行了一层封装，当只有一个线程读，多个线程取；一个线程取，多个线程读，读、写是不用同时加锁...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值