C语言条件变量和信号量两种方式实现生产者消费者问题

最新推荐文章于 2024-08-13 20:01:49 发布
最新推荐文章于 2024-08-13 20:01:49 发布
阅读量1.9k 收藏 31
点赞数 1
分类专栏： C/C++ 文章标签： 多线程 操作系统 C 生产者消费者
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A657997301/article/details/110298634
版权

一、使用互斥锁和条件变量实现

三种思路都可以，推荐第1种简单好记：

1、万金油思路，生产者和消费者都有条件等待和唤醒

生产者拿到互斥锁后，检查缓冲区的产品数量：
如果缓冲区是满的，则生产者条件等待
如果缓冲区不是满的，就生产，然后发送信号唤醒消费者消费，释放互斥锁

消费者拿到互斥锁后，检查缓冲区的产品数量：
如果缓冲区是空的，则消费者条件等待
如果缓冲区不是空的，就消费，然后发送信号唤醒生产者生产，释放互斥锁

2、只有消费者条件等待，生产者负责唤醒

生产者拿到互斥锁后，检查缓冲区的产品数量：
如果缓冲区不是满的，就生产，然后发送信号唤醒消费者消费，释放互斥锁

消费者拿到互斥锁后，检查缓冲区的产品数量：
如果缓冲区是空的，则消费者条件等待
如果缓冲区不是空的，就消费，释放互斥锁

3、只有生产者条件等待，消费者负责唤醒

生产者拿到互斥锁后，检查缓冲区的产品数量：
如果缓冲区是满的，则生产者条件等待
如果缓冲区不是满的，就生产，释放互斥锁

消费者拿到互斥锁后，检查缓冲区的产品数量：
如果缓冲区不是空的，就消费，然后发送信号唤醒生产者生产，释放互斥锁

第1种的代码实现

第2，3两种是子集，只需要去除对应代码即可

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

// 生产者消费者的数量 
#define CONSUMER 5
#define PRODUCER 5
// 缓冲区最大数目 
#define BUFFER_SIZE 10

pthread_mutex_t g_mutex;
pthread_cond_t g_cond;

typedef struct st_buffer_t {
    int buf[BUFFER_SIZE]; // 缓冲区 
    int count; // 剩余产品的数量 
	int in; // 生产者放置产品的位置
	int out; // 消费者取产品的位置	
} buffer_t;

buffer_t g_buff = {{0}, 0, 0, 0};

// 打印缓冲情况
void print()
{
	for (int i = 0; i < BUFFER_SIZE; i++) {
		printf("%d ", g_buff.buf[i]);
	}
	printf("\n");
}

void* producer(void *arg)
{
	int producer_id = *(int *)arg;
    printf("Producer %d starting.\n", producer_id);
    while (1) {
    	// 用sleep可以降低生产和消费的速度，便于观察
    	sleep(1);

        pthread_mutex_lock(&g_mutex);
        // 加上while防止线程错误唤醒 
        while (g_buff.count == BUFFER_SIZE) {
        	// 走到这里wait时会把互斥锁释放掉
        	pthread_cond_wait(&g_cond, &g_mutex);
		}

    	// 生产 
    	g_buff.in %= BUFFER_SIZE;
        g_buff.buf[g_buff.in] = 1;
        printf("Prodcuer %d produce 1 in %d: ", producer_id, g_buff.in);
        print();
        g_buff.in++;
        g_buff.count++;

        // 生产后发送信号唤醒消费者线程
        pthread_cond_signal(&g_cond);
        pthread_mutex_unlock(&g_mutex);
    }
    return NULL;
}

void* consumer(void *arg)
{
	int consumer_id = *(int *)arg;
    printf("Consumer %d starting.\n", consumer_id);
    while (1) {
    	// 用sleep可以降低生产和消费的速度，便于观察
    	sleep(1);

        pthread_mutex_lock(&g_mutex);
        // 加上while防止线程错误唤醒 
        while (g_buff.count == 0) {
        	// 走到这里wait时会把互斥锁释放掉
        	pthread_cond_wait(&g_cond, &g_mutex);
		}

		// 消费 
        g_buff.out %= BUFFER_SIZE;
        printf("Consumer %d consume %d in %d: ", consumer_id, g_buff.buf[g_buff.out], g_buff.out);
        g_buff.buf[g_buff.out] = 0;
        print();
        g_buff.out++;
        g_buff.count--;
        
        // 消费后发送信号唤醒生产者线程
        pthread_cond_signal(&g_cond);
        pthread_mutex_unlock(&g_mutex);
    }
    return NULL;
}

int main(int argc, char *argv[])
{
	// 初始化互斥锁和条件变量 
	pthread_mutex_init(&g_mutex, NULL);
    pthread_cond_init(&g_cond, NULL);
	pthread_t consumers[CONSUMER];
	pthread_t producers[PRODUCER];
	int consumers_id[CONSUMER];
	int producers_id[PRODUCER];
	// 创建生产者和消费者的线程 
	for (int i = 0, j = 0; i < CONSUMER || j < PRODUCER; i++, j++) {
		if (j < PRODUCER) {
			producers_id[j] = j;
			pthread_create(&producers[j], NULL, producer, (void *)&producers_id[j]);
		}
		if (i < CONSUMER) {
			consumers_id[i] = i;
			pthread_create(&consumers[i], NULL, consumer, (void *)&consumers_id[i]);
		}
	}
	for (int i = 0, j = 0; i < CONSUMER || j < PRODUCER; i++, j++) {
		if (j < PRODUCER) {
			pthread_join(producers[j], NULL);
		}
		if (i < CONSUMER) {
			pthread_join(consumers[i], NULL);
		}
	}
	// 销毁互斥锁和条件变量 
    pthread_mutex_destroy(&g_mutex);
    pthread_cond_destroy(&g_cond);
    return 0;
}

二、使用互斥锁和同步信号量实现

思路：

两个信号量，一个empty表示可生产产品的数量，一个full表示已生产产品的数量
生产者wait empty减一后，拿到互斥锁，生产，释放互斥锁，post full加一
消费者wait full减一后，拿到互斥锁，消费，释放互斥锁，post empty加一

PS：一般推荐两个保持先同步再互斥，这样可以使得互斥区代码更短，有效提高并发性。

代码实现

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

// 生产者消费者的数量 
#define CONSUMER 5
#define PRODUCER 5
// 缓冲区最大数目 
#define BUFFER_SIZE 10

pthread_mutex_t g_mutex;
sem_t g_empty_sem;
sem_t g_full_sem;

typedef struct st_buffer_t {
    int buf[BUFFER_SIZE]; // 缓冲区 
    int count; // 剩余产品的数量 
	int in; // 生产者放置产品的位置
	int out; // 消费者取产品的位置	
} buffer_t;

buffer_t g_buff = {{0}, 0, 0, 0};

// 打印缓冲情况
void print()
{
	for (int i = 0; i < BUFFER_SIZE; i++) {
		printf("%d ", g_buff.buf[i]);
	}
	printf("\n");
}

void* producer(void *arg)
{
	int producer_id = *(int *)arg;
    printf("Producer %d starting.\n", producer_id);
    while (1) {
    	// 用sleep可以降低生产和消费的速度，便于观察
    	sleep(1);

		// 等待empty信号量大于0
		sem_wait(&g_empty_sem);
        pthread_mutex_lock(&g_mutex);

    	// 生产 
    	g_buff.in %= BUFFER_SIZE;
        g_buff.buf[g_buff.in] = 1;
        printf("Prodcuer %d produce 1 in %d: ", producer_id, g_buff.in);
        print();
        g_buff.in++;
        g_buff.count++;

        pthread_mutex_unlock(&g_mutex);
        // 增加full信号量的值 
        sem_post(&g_full_sem);
    }
    return NULL;
}

void* consumer(void *arg)
{
	int consumer_id = *(int *)arg;
    printf("Consumer %d starting.\n", consumer_id);
    while (1) {
    	// 用sleep可以降低生产和消费的速度，便于观察
    	sleep(1);

		// 等待empty信号量大于0 
		sem_wait(&g_full_sem);
        pthread_mutex_lock(&g_mutex);

		// 消费 
        g_buff.out %= BUFFER_SIZE;
        // 可以通过g_buff.buf[g_buff.out]的值来判断消费者是否消费对了，该值必须为1 
        printf("Consumer %d consume %d in %d: ", consumer_id, g_buff.buf[g_buff.out], g_buff.out);
        g_buff.buf[g_buff.out] = 0;
        print();
        g_buff.out++;
        g_buff.count--;

        pthread_mutex_unlock(&g_mutex);
        // 增加empty信号量的值 
        sem_post(&g_empty_sem);
    }
    return NULL;
}

int main(int argc, char *argv[])
{
	// 初始化互斥锁和同步信号量
	// empty表示可生产的数量；full表示已生产的数量 
	pthread_mutex_init(&g_mutex, NULL);
	sem_init(&g_empty_sem, 0, BUFFER_SIZE);
	sem_init(&g_full_sem, 0, 0);  
	pthread_t consumers[CONSUMER];
	pthread_t producers[PRODUCER];
	int consumers_id[CONSUMER];
	int producers_id[PRODUCER];
	// 创建生产者和消费者的线程 
	for (int i = 0, j = 0; i < CONSUMER || j < PRODUCER; i++, j++) {
		if (j < PRODUCER) {
			producers_id[j] = j;
			pthread_create(&producers[j], NULL, producer, (void *)&producers_id[j]);
		}
		if (i < CONSUMER) {
			consumers_id[i] = i;
			pthread_create(&consumers[i], NULL, consumer, (void *)&consumers_id[i]);
		}
	}
	for (int i = 0, j = 0; i < CONSUMER || j < PRODUCER; i++, j++) {
		if (j < PRODUCER) {
			pthread_join(producers[j], NULL);
		}
		if (i < CONSUMER) {
			pthread_join(consumers[i], NULL);
		}
	}
	// 销毁互斥锁和条件变量 
    pthread_mutex_destroy(&g_mutex);
	sem_destroy(&g_empty_sem);
	sem_destroy(&g_full_sem);
    return 0;
}
陈小星_绛菱纱影
关注
专栏目录
使用信号量实现生产者消费者|C语言
lin3ux的博客
05-09 1906
本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。 Intro 本文为多生产者多消费者的C语言实现 生产者与消费者针对链表的头结点进行操作 使用的现场同步方法为信号量 本文侧重于理解条件变量的使用 为保证代码简洁，本文代码没有对函数的返回值进行检查，聪明的你一定一定知道如何检查这个小细节(•̀ᴗ•́)و ̑̑ 关于互斥锁+条件变量的多生产者多消费者模型实现请参考我的这篇博客 analysis 多生产者多消费者有多个线程，当根据信号量定义的资源数不同，所对应的情况也有所不.
生产者消费者问题 伪代码和C语言多线程实现
热门推荐
chen_mama的专栏
08-11 1万+
生产者消费者问题是操作系统中的一个经典的问题。他描述的是一个，多个生产者与多个消费者共享多个缓冲区的事情，具体的定义百度。然后看了操作系统的书籍如何解决书上给的伪代码是这样的item B[k]; semaphore empty; empty=k; //可以使用的空缓冲区数 semaphore full; full=0; //缓冲区内可以使用的产品数 semaphore mut
【操作系统】c语言--使用信号量解决生产者和消费者问题
努力让自己的能力配得上梦想.
07-05 1148
信号量 信号量是一种同步机制，可用于保护共享资源，控制进程的访问以及协调进程之间的通信。 在生产者和消费者问题中，可以使用两个信号量：一个用于生产者，另一个用于消费者。假设缓冲区的大小为N，生产者信号量的初始值为N，消费者信号量的初始值为0。接下来，生产者和消费者可以使用P操作和V操作来访问缓冲区。 P操作（等待信号量）：如果信号量的值为0，则进程将阻塞，直到信号量的值变为正数。如果信号量的值大于0，则进程将减少信号量的计数器并继续执行。 V操作（释放信号量）：如果有进程在等待信号量，则唤醒其中一个进
操作系统（线程管理-通过条件变量实现消费者与生产者模型）
最新发布
weixin_65029285的博客
08-13 893
也叫数据仓库，是生产者线程与消费者线程之间的数据缓冲区，用于平衡二者之间的生产速度与消耗速度不均衡的问题，通过缓冲区隔离生产者和消费者，与二者直连相比，避免相互等待，提高运行效率。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起，一般线程睡入条件变量，伴随着解锁动作，而线程从条件变量醒来时，伴随着加锁动作，如果加锁失败线程进入阻塞状态，而不是睡眠。注意：使用互斥锁配合条件变量实现的生产者与消费者模型，能够平衡生产与消费的时间不协调，并且可以最大限度的节约运行资源。2、等"条件成立"叫醒休眠的线程。
＜生产者消费者模型-C线程信号量机制实现＞
weixin_45540964的博客
12-03 201
#include <stdio.h> #include <unistd.h> #include <semaphore.h> #include <pthread.h> #include <stdlib.h> #include <string.h> #define max 5 int queue[max];//产品存取缓冲区 sem_t blank_num; sem_t product_num;//定义缓冲区空区数量和生产产品数量 voi
信号量实现生产者消费者程序_C语言示例
weixin_43158544的博客
03-17 620
信号量实现生产者消费者程序_C语言
C语言信号量同步与互斥生产者消费者互斥锁读写者问题哲学家就餐问题课程设计
04-20
在实验中，我们使用C语言编程来实现信号量机制下的同步、互斥、生产者消费者问题、哲学家就餐问题和读写者问题。实验结果表明，信号量机制可以有效地解决这些问题。 本课程设计旨在通过C语言编程来解决信号量机制下...
C语言实现生产者消费者（条件变量和信号量）问题？
weixin_43748094的博客
12-08 549
条件变量实现如下： #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <pthread.h> //节点结构体 struct msg { int num; //数据区 struct msg *next; //链表区 }; struct msg *head = NULL;//头指针 //struct msg *mp = NULL; //节点指针 //利用宏定义
OS大作业生产者消费者同步问题的实现
07-16
在某些实现中，信号量可以替代条件变量来实现生产者-消费者同步，但这里并未实际使用。 7. **线程创建与同步**：`pthread_create`函数用于创建新的线程，`pthread_join`用于等待线程结束。在主函数中，分别创建了...
（Linux C）利用多进程或多线程模拟实现生产者/消费者问题
02-11
总结，生产者/消费者问题的解决策略主要依赖于同步机制，如信号量、互斥锁和条件变量。在Linux C环境下，多进程和多线程都可以有效地实现这一模型，但它们各有优缺点，选择哪种方式取决于具体的应用场景和性能需求。...
生产者消费者问题c语言实现
dawohao4224的博客
05-28 917
1 #include <stdio.h> 2 #include <process.h> 3 #include <Windows.h> 4 //信号量与关键段 5 CRITICAL_SECTION g_cs; 6 HANDLE Empty,Full; 7 8 const int BUFFER_SIZE=10;//1...
操作系统-生产者与消费者问题的C语言实现
03-06
1．模拟用信号量机制实现生产者和消费者问题。 2．设计报告内容应说明： ⑴ 课程设计目的与功能； ⑵ 需求分析，数据结构或模块说明(功能与框图)； ⑶ 源程序的主要部分； ⑷ 运行结果与运行情况分析； ⑸ 自我评价与总结：
Linux环境下C语言实现生产者消费者问题的代码
03-11
在Linux下完整C语言实现生产者消费者问题的代码。其中涉及信号量、多线程、GCC编译、PV操作等基础知识。Linux下通过gcc - o yy xxx.c -pthread，再通过./yy即可运行。
C语言实现生产者消费者问题
05-27
C语言实现生产者消费者问题，分配具有n个缓冲区的缓冲池，作为共享资源。 定义两个资源型信号量empty 和full，empty信号量表示当前空的缓冲区数量，full表示当前满的缓冲区数量。 定义互斥信号量mutex，当某个进程访问缓冲区之前先获取此信号量，在对缓冲区的操作完成后再释放此互斥信号量。以此实现多个进程对共享资源的互斥访问。 创建3进程（或者线程）作为生产者，4个进程（或者线程）作为消费者。创建一个文件作为数据源，文件中事先写入一些内容作为内容。 编写代码实现生产者进程的工作内容，即从文件中读取数据，然后申请一个empty信号量，和互斥信号量，然后进入临界区操作将读取的数据放入此缓冲区中。并释放empty信号量和互斥信号量。
生产者消费者操作系统实验报告用C语言来实现
m0_58325342的博客
05-22 9257
#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> #include <time.h> //宏定义一些变量和信号量，方便进行调试 #define N 10 //缓冲区的大小 #define ProNum 2 //生产者的数量 #define ConNum 2 //消费者的数量 #define SleepTime 3 //生
C语言实现生产者消费者模型(线程、信号量、互斥锁)
weixin_43030270的博客
11-10 2573
C 线程
【C语言】【Linux】【信号量 P.V操作】 生产者消费者问题实现
CyberQuirk
03-11 4404
简述P/V操作原理、信号量概念，以及Ubuntu18.04下实现生产者消费者的代码演示。
生产者消费者问题的C语言代码实现
bruce_devil的博客
04-05 1733
线程互斥是指对于共享的进程系统资源, 在各单个线程访问时的排它性. 当有若干个线程都要使用某一共享资源时, 任何时刻最多只允许一个线程去使用, 其它要使用该资源的线程必须等待, 直到占用资源者释放该资源.上图第一次执行的时候是左边的线程, 下一次执行未必是右边的线程, 左边的线程可以连续执行两次或三次, 然后才到右边的线程执行, 互斥只需要保证只能有一个线程执行就是互斥,互斥加有序就是同步,
c/c++基于信号量+线程锁实现生产者消费者
u012094479的博客
06-24 315
C语言实现：生产者消费者问题互斥解决代码详解
生产者消费者问题是一种经典的并发编程问题，它涉及到两个线程：生产者和消费者，它们之间通过共享数据进行交互。问题的核心是确保生产者不会在缓冲区满时继续添加产品，而消费者也不会在缓冲区为空时立即尝试消费。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值