生产者消费者问题(Producer-consumer problem)

概述

生产者消费者问题,也称有限缓冲问题(英语:Bounded-buffer problem),是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。其中生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程。与此同时,消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区中空时消耗数据。

问题分析

1.要保证不让生产者在缓存还是满的时候仍然要向内写数据;
2.不让消费者试图从空的缓存中取出数据。
生产者和消费者对缓冲区互斥访问是互斥关系,同时生产者和消费者又是一个相互协作的关系,只有生
产者生产之后,消费者才能消费,他们也是同步关系。

只有生产者和消费者两个进程,正好是这两个进程存在着互斥关系和同步关系。那么需要解决的是互斥
和同步PV操作的位置。我们使用了三个信号量:full 和 empty用来解决唤醒的问题 ,而信号量mutex作为互斥信号量,它用于控制互斥访问缓冲池,互斥信号量初值为 1;信号量 full 用于记录当前缓冲池中“满”缓冲区数,初值为0。信号量 empty 用于记录当前缓冲池中“空”缓冲区数,初值为n。新的数据添加到缓存中后,full 在增加,而 empty 则减少。如果生产者试图在 empty 为0时减少其值,生产者就会被阻塞。下一轮中有数据被消费掉时,
empty就会增加,生产者就会被“唤醒”。

mypro.c

/*************************************************************************
	> File Name: mypro.c
	> Author: Xianghao Jia
	> mail: xianghaojia@sina.com
	> Created Time: Mon 18 Nov 2019 07:03:41 PM PST
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "queue.h"

#define CONSUMER_COUNT

sem_t vacancy;//空位
sem_t goods;//物品数量
sem_t sem_mutex;//互斥信号量

int main(int argc, char ** argv)
{
	pthread_t consumer_id[3];
	pthread_t productor_id;
	// 创建队列
	QUEUE * queue = queue_init();
	if(queue == NULL)
	{
		return -1;
	}
	// 初始化信号量
	sem_init(&vacancy, 0, 10);
	sem_init(&good, 0, 0);
	sem_init(&sem_mutex ,0 , 1);

	int i = 0;
	// 创建3个消费者
	for(i = 0; i < CONSUMER_COUNT; i++)
	{
		if(0 == pthread_create(&consumer_id[i], NULL, consumer_routine, queue_head))
		{
			perror("pthread_create");
			exit(1);
		}
	}
	// 创建生产者
	if(0 == pthread_create(&consumer_id[i], NULL, productor_routine, queue_head))
	{
		perror("pthread_create");
		exit(1);
	}
	// 用来停止程序
	getchar();

	// 取消线程
	for(i = 0; i < CONSUMER_COUNT; i++)
	{
		pthread_cancel(consumer_id[i]);
	}
	// 接合线程
	pthread_join(productor_id, NULL);
	for(i = 0; i < CONSUMER_COUNT; i++)
	{
		pthread_join(consumer_id[i], NULL);
	}
	
	// 销毁信号量
	sem_destroy(&vacancy);
	sem_destroy(&goods);
	sem_destroy(&sem_mutex);
	// 销毁队列
	queue_destroy(queue);

	return 0;
}


void *consumer_routine(void *arg)
{	
	printf("thread consumer start...\n");
	QUEUE * queue = (QUEUE *)arg;

	while(1)
	{
		sem_wait(&goods);
		sem_wait(&sem_mutex);
		
		if(exit_flag == 1)
		{
			printf("thread consumer is exiting\n");
			break;
		}
		// 获得队列首
		printf("consume %d\n",queue_front(queue));
		// 弹出队首
		queue_out(queue);
	
		sem_post(&sem_mutex);
		sem_post(&vacancy);
		usleep(random() % 10000);
	}
	pthread_exit(NULL);
}

void *productor_routine(void *arg)
{
	printf("thread productor start...\n");
	QUEUE * queue = (QUEUE *)arg;

	while(1)
	{
		sem_wait(&vacancy);
		sem_wait(&sem_mutex);
		
		if(exit_flag == 1)
		{
			printf("thread productor is exiting\n");
			break;
		}
		// 创建节点到队列中
		int n = random() % 100;
		queue_in(queue, n);
		printf("product %d\n", n);

		sem_post(&sem_mutex);
		sem_post(&goods);
		usleep(random() % 10000);
	}
	pthread_exit(NULL);	
}

queue.h

#ifndef _QUEUE_H
#define _QUEUE_H
#define QUEUE_DEEP 10

extern int myerror;

typedef struct Node
{
	//	BINODE *pnode;
	int num;
	int count;
	struct Node *next;
}QNODE, QUEUE;

int queue_is_empty(QNODE *queue);
void queue_destroy(QNODE *queue);
int queue_out(QNODE *queue);
int queue_in(QNODE *queue, int n);
int queue_front(QNODE *queue);
int queue_is_full(QNODE *queue);
QNODE *queue_init();
#endif

queue.c

#include "queue.h"
#include <stdio.h>

int myerror = 0;

QNODE *queue_init()
{
	QNODE *head = malloc(sizeof(QNODE));
	if (head == NULL)
	{
		return NULL;
	}
	memset(head, sizeof(QNODE));
	return head;
}

int queue_is_empty(QNODE *queue)
{
	return queue->next == NULL;
}
void queue_destroy(QNODE *queue)
{
	while (queue != NULL)
	{
		QNODE *temp = queue->next;
		free(queue);
		queue = temp;
	}
}
/*
	取出队列首段的元素
*/
int queue_out(QNODE *queue)
{
	if (queue->next == NULL)
	{
		return -1;
	}
	QNODE * temp = queue->next;
	queue->next = temp->next;
	free(temp);
	return 0;
}
/*
	将元素添加到队尾
*/
int queue_in(QNODE *queue, int n)
{
	while (queue->next)
	{
		queue = queue->next;
	}
	QNODE * temp = malloc(sizeof(QNODE));
	if (temp == NULL)
	{
		return -1;
	}
	temp->next = NULL;
	temp->num = n;
	queue->next = temp;
	return 0;
}
int queue_front(QNODE *queue)
{
	if (queue->next == NULL)
	{
		myerror = 1;
		return -1;
	}
	return queue->next->num;
}

  • 0
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
程序流程图: ``` +------------------+ | Producer | +------------------+ | | lock(mutex) wait(not_full) | | put_item() signal(not_empty) | | unlock(mutex) | | | +------+ +------+ | Buffer | | | +------+ +------+ | lock(mutex) | get_item() | unlock(mutex) | signal(not_full) | | lock(mutex) +------+ | | | get_item() +------+ | | unlock(mutex) wait(not_empty) | +------+ |Consumer| +------+ ``` 具体步骤: 1. 定义一个有限缓冲区(Buffer)和至少2个生产者(Producer)线程以及1个或若干个消费者(Consumer)线程。 2. 使用POSIX线程同步机制互斥锁(mutex)和条件变量(not_empty, not_full)实现同步。 3. 生产者线程在生成数据(产品)后,使用lock(mutex)获取互斥锁,判断缓冲区是否满,如果满了就使用wait(not_full)等待条件变量not_full的信号。如果缓冲区没有满,则将数据放入缓冲区中,再使用signal(not_empty)发送条件变量not_empty的信号,最后使用unlock(mutex)释放互斥锁。 4. 消费者线程在消耗数据之前,使用lock(mutex)获取互斥锁,判断缓冲区是否为空,如果为空就使用wait(not_empty)等待条件变量not_empty的信号。如果缓冲区不为空,则从缓冲区中取出数据并使用unlock(mutex)释放互斥锁,再使用signal(not_full)发送条件变量not_full的信号。 5. 当生产者线程将数据放入缓冲区时,如果缓冲区满了就会等待条件变量not_full的信号。当消费者线程从缓冲区中取出数据时,如果缓冲区为空就会等待条件变量not_empty的信号。这样就可以保证生产者不会在缓冲区满时放入数据,而消费者也不会在缓冲区中空时消耗数据。 6. 生产者线程和消费者线程的数量可以根据具体情况进行调整。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值