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

最新推荐文章于 2024-05-22 11:14:53 发布
最新推荐文章于 2024-05-22 11:14:53 发布
阅读量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;
}
陈小星_绛菱纱影
关注
  • 1
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下生产者消费者问题的C语言实现
Yuhan2001的CSDN博客
12-05 8725
操作系统的课程实验，在Linux下生产者-消费者问题的C语言实现。
C语言实现生产者消费者（条件变量和信号量）问题？
weixin_43748094的博客
12-08 520
条件变量实现如下： #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; //节点指针 //利用宏定义
C语言实现生产者消费者问题
05-27
C语言实现生产者消费者问题，分配具有n个缓冲区的缓冲池，作为共享资源。 定义两个资源型信号量empty 和full，empty信号量表示当前空的缓冲区数量，full表示当前满的缓冲区数量。 定义互斥信号量mutex，当某个进程访问缓冲区之前先获取此信号量，在对缓冲区的操作完成后再释放此互斥信号量。以此实现多个进程对共享资源的互斥访问。 创建3进程（或者线程）作为生产者，4个进程（或者线程）作为消费者。创建一个文件作为数据源，文件中事先写入一些内容作为内容。 编写代码实现生产者进程的工作内容，即从文件中读取数据，然后申请一个empty信号量，和互斥信号量，然后进入临界区操作将读取的数据放入此缓冲区中。并释放empty信号量和互斥信号量。
Linux c语言实现一个生产者和消费者
最新发布
海涛高软
05-22 331
这段代码实现了一个简单的生产者-消费者模型，其中包含了一个有限缓冲区。它使用了条件变量来同步生产者和消费者，确保在缓冲区为空或为满时不会消耗或生产数据，从而避免了竞态条件。这个例子教会了如何在Linux环境下使用C语言编写并发程序。FR：徐海涛（hunk Xu)
C语言 生产者消费者问题
qq_45740212的博客
01-29 3647
本文介绍并实现了生产者消费者经典进程同步问题
生产者与消费者问题（C语言 超详细全）小白可入
Zjyzzy123456789的博客
11-05 7286
【代码】生产者与消费者问题（详细全）
用c语言实现“生产者和消费者”问题
weixin_52451652的博客
04-18 8100
实验要求：要求程序运行时，按任意键停止，显示各种信息 #include <stdio.h> #include<stdlib.h> #include<time.h> int mutex=1; int empty=10; int full=0; int buf[10]; int front=0,rear=0; int i; //p操作 .申请 void p(int *x) { *x=(*x)-1; } //v操作 .释放 void v(int *x) { *x=
C语言信号量同步与互斥生产者消费者互斥锁读写者问题哲学家就餐问题课程设计
04-20
在实验中，我们使用C语言编程来实现信号量机制下的同步、互斥、生产者消费者问题、哲学家就餐问题和读写者问题。实验结果表明，信号量机制可以有效地解决这些问题。 本课程设计旨在通过C语言编程来解决信号量机制下...
OS大作业生产者消费者同步问题的实现
07-16
在某些实现中，信号量可以替代条件变量来实现生产者-消费者同步，但这里并未实际使用。 7. **线程创建与同步**：`pthread_create`函数用于创建新的线程，`pthread_join`用于等待线程结束。在主函数中，分别创建了...
（Linux C）利用多进程或多线程模拟实现生产者/消费者问题
02-11
总结，生产者/消费者问题的解决策略主要依赖于同步机制，如信号量、互斥锁和条件变量。在Linux C环境下，多进程和多线程都可以有效地实现这一模型，但它们各有优缺点，选择哪种方式取决于具体的应用场景和性能需求。...
Linux线程编程之生产者消费者问题
12-14
生产者消费者问题的解决方案通常需要借助于线程同步机制，如互斥锁（mutex）、条件变量（condition variable）或者信号量（semaphore）。 在本文中，作者提出了基于顺序循环队列的实现方式。顺序循环队列是一种特殊...
生产者消费者操作系统实验报告用C语言来实现
m0_58325342的博客
05-22 9232
#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语言实现)
ZWR的博客
04-09 1365
#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <pthread.h> #include <semaphore.h> sem_t full,mutex; int a=0; void *producer_i(void *arg){ while(1){ sleep(1); sem_wait(&mu
C语言生产者与消费者问题
jakelihua
05-07 3881
编写一个简单的生产者-消费者（producer-consumer）模型，其中包含一个生产者进程和一个消费者进程以及一个共享的缓冲区（使用队列或环形缓冲区）。其中 empty 的初始值应为缓存队列的大小，而 full 的初始值则应为 0。由于这是一个生产者-消费者模型的程序，最终的运行结果是不确定的。在该程序中，使用 PV 机制和互斥量来控制对缓存区的并发访问，保证了两个线程能够安全地使用共享数据组成的缓冲区。因此，最终的结果将取决于各种线程之间的执行顺序和时间分配。
一文搞懂信号量机制（内含消费者生产者问题）
m0_63006478的博客
05-12 4093
信号量（Semaphore）是一种用于实现多线程之间同步的机制。它是由荷兰计算机科学家Dijkstra于1965年首先提出的。Semaphore可以控制同时访问某个资源的线程数量，以保证多个线程能够正确、合理的使用共享资源。Semaphore有两种类型：二元信号量和计数信号量。二元信号量也称为互斥量（Mutex），用于保护共享资源的互斥访问，只允许一个线程访问该资源。计数信号量用于控制某个共享资源的可用数量，允许多个线程同时访问该资源，但需要控制访问数量，以避免竞争和冲突。
信号量实现生产者消费者程序_C语言示例
weixin_43158544的博客
03-17 599
信号量实现生产者消费者程序_C语言
【操作系统】c语言--使用信号量解决生产者和消费者问题
努力让自己的能力配得上梦想.
07-05 1122
信号量 信号量是一种同步机制，可用于保护共享资源，控制进程的访问以及协调进程之间的通信。 在生产者和消费者问题中，可以使用两个信号量：一个用于生产者，另一个用于消费者。假设缓冲区的大小为N，生产者信号量的初始值为N，消费者信号量的初始值为0。接下来，生产者和消费者可以使用P操作和V操作来访问缓冲区。 P操作（等待信号量）：如果信号量的值为0，则进程将阻塞，直到信号量的值变为正数。如果信号量的值大于0，则进程将减少信号量的计数器并继续执行。 V操作（释放信号量）：如果有进程在等待信号量，则唤醒其中一个进
操作系统——生产者消费者问题
mainjay的博客
10-31 2203
【代码】操作系统——lab12。
使用信号量实现生产者消费者|C语言
lin3ux的博客
05-09 1889
本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。 Intro 本文为多生产者多消费者的C语言实现 生产者与消费者针对链表的头结点进行操作 使用的现场同步方法为信号量 本文侧重于理解条件变量的使用 为保证代码简洁，本文代码没有对函数的返回值进行检查，聪明的你一定一定知道如何检查这个小细节(•̀ᴗ•́)و ̑̑ 关于互斥锁+条件变量的多生产者多消费者模型实现请参考我的这篇博客 analysis 多生产者多消费者有多个线程，当根据信号量定义的资源数不同，所对应的情况也有所不.
利用信号量 和进程 实现 生产者-消费者问题，c语言实现
04-24
好的，下面是生产者-消费者问题的代码示例，利用信号量和进程来实现： ``` #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <pthread.h> #include <semaphore.h> #define MAX_BUFF_SIZE 10 // 缓冲区大小 #define MAX_PROD_NUM 20 // 生产者生产的最大数量 // 缓冲区 char buffer[MAX_BUFF_SIZE] = {0}; int in = 0, out = 0; // 信号量 sem_t empty_sem; // 空槽位数量 sem_t full_sem; // 已填充槽位数量 sem_t mutex_sem; // 互斥信号量 // 生产者线程 void* producer(void* arg) { int num = *(int*)arg; for (int i = 0; i < num; i++) { sem_wait(&empty_sem); // 获取空槽位 sem_wait(&mutex_sem); // 获取互斥权 buffer[in] = 'A' + i % 26; printf("producer %lu: produce %c\n", pthread_self(), buffer[in]); in = (in + 1) % MAX_BUFF_SIZE; sem_post(&mutex_sem); // 释放互斥权 sem_post(&full_sem); // 填充一个槽位 sleep(1); // 等待一段时间 } pthread_exit(NULL); } // 消费者线程 void* consumer(void* arg) { int num = *(int*)arg; for (int i = 0; i < num; i++) { sem_wait(&full_sem); // 获取已填充槽位 sem_wait(&mutex_sem); // 获取互斥权 printf("consumer %lu: consume %c\n", pthread_self(), buffer[out]); buffer[out] = 0; out = (out + 1) % MAX_BUFF_SIZE; sem_post(&mutex_sem); // 释放互斥权 sem_post(&empty_sem); // 释放一个空槽位 sleep(1); // 等待一段时间 } pthread_exit(NULL); } int main() { int prod_num = 6, cons_num = 4; // 初始化信号量 sem_init(&empty_sem, 0, MAX_BUFF_SIZE); sem_init(&full_sem, 0, 0); sem_init(&mutex_sem, 0, 1); // 创建生产者线程 pthread_t prod_tid, prod_tid2; pthread_create(&prod_tid, NULL, producer, (void*)&prod_num); pthread_create(&prod_tid2, NULL, producer, (void*)&prod_num); // 创建消费者线程 pthread_t cons_tid, cons_tid2; pthread_create(&cons_tid, NULL, consumer, (void*)&cons_num); pthread_create(&cons_tid2, NULL, consumer, (void*)&cons_num); // 等待线程结束 pthread_join(prod_tid, NULL); pthread_join(prod_tid2, NULL); pthread_join(cons_tid, NULL); pthread_join(cons_tid2, NULL); // 销毁信号量 sem_destroy(&empty_sem); sem_destroy(&full_sem); sem_destroy(&mutex_sem); return 0; } ``` 代码说明： 1. 定义全局变量 `buffer` 作为缓冲区，变量 `in` 和 `out` 分别表示插入和读取缓冲区的位置。 2. 定义三个信号量 `empty_sem`, `full_sem`, `mutex_sem`，分别表示空槽位数量、已填充槽位数量和互斥信号量。 3. 在生产者和消费者函数中，使用 `sem_wait` 和 `sem_post` 操作信号量，来实现同步和互斥。 4. 程序中创建 2 个生产者线程和 2 个消费者线程，它们分别使用 `pthread_create` 函数创建，等待线程结束使用 `pthread_join` 函数。 5. 程序结束时使用 `sem_destroy` 函数销毁信号量。 这个程序使用了信号量和互斥信号量来解决生产者-消费者问题，保证了生产者和消费者之间的同步和互斥，可以避免竞态条件和死锁的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值