生产者消费者——一对一

最新推荐文章于 2021-01-11 19:48:06 发布

原创最新推荐文章于 2021-01-11 19:48:06 发布 · 533 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#生产者消费者 #互斥量 #条件变量 #有界缓冲区

//【IPC与网络部分】专栏收录该内容

25 篇文章

订阅专栏

本文介绍了一个经典的同步问题——生产者消费者问题的实现方法，通过C语言和POSIX线程库来演示如何在一个有界缓冲区中实现一对一的生产者与消费者模型。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

同步中有一个“生产者消费者”的经典问题，也叫它“有界缓冲区”

生产者生产数据，消费者取数据是消费(取出)数据。”数据多，空间少”才能造成生产者消费者问题
(数据)空的时候不能消费，(空间)满的时候不能生产.

这一篇实现一个生产者对应一个消费者，即一对一的情况

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

#define MAX_PRODUCER_SIZE 1
#define MAX_CONSUMER_SIZE 1
#define MAX_COUNT 20
#define MAX_BUFFER_SIZE 8

struct pcst
{
    pthread_mutex_t mutex;
    pthread_cond_t not_full;
    pthread_cond_t not_empty;
    int buffer[MAX_BUFFER_SIZE];
    int write_pos;
    int read_pos;
    int nvalue;
}shared = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER,
    PTHREAD_COND_INITIALIZER};
//注意not_full/not_empty是一个结构体，系统中它的初始化是PTHREAD_MUTEX_INITIALIZER，这个东西是以宏的形式定义的，所以在这里就对not_full/not_empty进行初始化比较方便，不然后面对它赋值时，相当于给一个结构体赋值，编译会报错。类似结尾给出的一样

void init_pcst()
{
    shared.write_pos = 0;
    shared.read_pos = 0;
    shared.nvalue = 1;
}
void put_value(struct pcst *pc, int value)
{
    pthread_mutex_lock(&pc->mutex);
    if((pc->write_pos+1)%MAX_BUFFER_SIZE == pc->read_pos)
        pthread_cond_wait(&pc->not_full, &pc->mutex);

    pc->buffer[pc->write_pos++] = value;
    pc->write_pos %= MAX_BUFFER_SIZE;

    pthread_cond_signal(&pc->not_empty);
    pthread_mutex_unlock(&pc->mutex);
}

int get_value(struct pcst *pc)
{
    pthread_mutex_lock(&pc->mutex);
    if(pc->read_pos == pc->write_pos)
        pthread_cond_wait(&pc->not_empty, &pc->mutex);

    int data = pc->buffer[pc->read_pos++];
    pc->read_pos %= MAX_BUFFER_SIZE;

    pthread_cond_signal(&pc->not_full);
    pthread_mutex_unlock(&pc->mutex);
    return data;
}
void* producer(void *arg)
{
    for(int i=1; i<=MAX_COUNT; ++i)
    {
        put_value(&shared, shared.nvalue);
        shared.nvalue++;
    }
}
void* consumer(void *arg)
{
    while(1)
    {
        int value = get_value(&shared);
        printf("%d\n", value);
        if(value >= MAX_COUNT)
            break;
       // sleep(1);
    }
}
int main(int argc, char const* argv[])
{
   // shared.write_pos = shared.read_pos = 0;
    //shared.nvalue = 1;
    init_pcst();
    pthread_t p_id[MAX_PRODUCER_SIZE];
    pthread_t c_id[MAX_CONSUMER_SIZE];
    for(int i=0; i<MAX_PRODUCER_SIZE; ++i)
    {
        pthread_create(&p_id[i], NULL, producer, NULL);
    }
    for(int i=0; i<MAX_CONSUMER_SIZE; ++i)
    {
        pthread_create(&c_id[i], NULL, consumer, NULL);
    }
    for(int i=0; i<MAX_PRODUCER_SIZE; ++i)
    {
        pthread_join(p_id[i], NULL);
    }
    for(int i=0; i<MAX_CONSUMER_SIZE; ++i)
    {
        pthread_join(c_id[i], NULL);
    }
    return 0;
}