设计模式-生产者消费者模式

0x00 引言

  生产者-消费者模式是一个十分经典的多线程并发协作^[1]的模式，严格地讲并不属于设计模式的范畴。
  在这个模式中，负责产生数据的模块被称为生产者，而处理数据的模块就称为消费者。并且在生产者与消费者之间设立一个缓冲区(数据仓库)，当生产者生产数据时锁住仓库，不让消费者访问，当消费者消费时锁住仓库，不让生产者访问仓库。

0x01 生产者消费者模式

  更复杂的生产者消费者模式应该能实现一部分线程被用于去生产数据，另一部分线程去处理数据。这里，我们将只有一个生产者线程和一个消费者线程的情况称为单缓冲，将多生产者线程、多消费者线程的情况称为多缓冲。

1 单缓冲
2 多缓冲

1、单缓冲

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

sem_t empty_sem; // 同步信号量， 当满了时阻止生产者放产品
sem_t full_sem; // 同步信号量， 当没产品时阻止消费者消费
pthread_mutex_t mutex; // 互斥信号量， 一次只有一个线程访问缓冲

int buffer = 0; //单缓冲
int product_id = 0; //生产者id
int consumer_id = 0; //消费者id
int product_sum = 0;
int consumer_sum = 0;

struct timeval start; //记录时间
struct timeval end;
unsigned long timer;

void *product(void *arg) {
    int id = ++product_id;
    int t = *(int *)arg;
    while (true) {
        sleep(t);
        sem_wait(&empty_sem);
        pthread_mutex_lock(&mutex);

        gettimeofday(&end, NULL);
        product_sum++;
        timer =
            1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
        printf("time:%ld product_%d is producing.SUM=%d\n", timer, id,
               product_sum);
        buffer = 1;

        pthread_mutex_unlock(&mutex);
        sem_post(&full_sem);
    }
}

void *consumer(void *arg) {
    int id = ++consumer_id;
    int t = *(int *)arg;
    while (true) {
        sleep(t);
        sem_wait(&full_sem);
        pthread_mutex_lock(&mutex);

        gettimeofday(&end, NULL);
        consumer_sum++;
        timer =
            1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
        printf("time:%ld consumer_%d is consumeing.SUM=%d\n", timer, id,
               consumer_sum);
        buffer = 0;

        pthread_mutex_unlock(&mutex);
        sem_post(&empty_sem);
    }
}

int main(int argc, char *argv) {
    gettimeofday(&start, NULL);
    
    sem_init(&empty_sem, 0, 1);
    sem_init(&full_sem, 0, 0);
    pthread_mutex_init(&mutex, NULL);
    pthread_t id1[1];
    pthread_t id2[1];
    int T1 = 1;
    int T2 = 1;
    pthread_create(&id1[1], NULL, product, &T1);
    pthread_create(&id2[1], NULL, consumer, &T2);
    pthread_join(id1[1], NULL);
    pthread_join(id2[1], NULL);
    
    return 0;
}

0x02 引用文献

[1]https://jenkov.com/tutorials/java-concurrency/producer-consumer.html