Implementing Producer-consumer Pattern in C for Multithreaded Applications

by

The producer-consumer pattern is a classic design used in multithreaded programming to coordinate the work between producer threads, which generate data, and consumer threads, which process that data. Implementing this pattern in C can help manage shared resources efficiently and prevent race conditions.

Understanding the Producer-Consumer Pattern

The core idea is to have a shared buffer where producers place items and consumers remove items. Proper synchronization ensures that producers do not overwrite data that consumers haven’t processed yet, and consumers do not read empty buffers.

Key Components of the Implementation

  • Shared Buffer: A data structure, often a queue, to hold items.
  • Mutex: Ensures mutual exclusion when accessing the buffer.
  • Condition Variables: Signal when the buffer is not empty (for consumers) or not full (for producers).
  • Threads: Separate producer and consumer threads perform their tasks concurrently.

Sample Implementation Outline

Here’s an outline of the main steps involved:

  • Initialize shared buffer, mutex, and condition variables.
  • Create producer and consumer threads.
  • Producers generate data, lock mutex, place data into buffer, signal consumers, and unlock mutex.
  • Consumers wait for data, lock mutex, remove data from buffer, process it, and unlock mutex.
  • Join threads and clean up resources after processing completes.

Sample Code Snippet

Below is a simplified example demonstrating the core logic:

Note: This code is for educational purposes and omits error handling for brevity.

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

#define BUFFER_SIZE 10

int buffer[BUFFER_SIZE];
int count = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t not_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t not_empty = PTHREAD_COND_INITIALIZER;

void* producer(void* arg) {
    for (int i = 0; i < 100; i++) {
        pthread_mutex_lock(&mutex);
        while (count == BUFFER_SIZE) {
            pthread_cond_wait(&not_full, &mutex);
        }
        buffer[count++] = i;
        pthread_cond_signal(&not_empty);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void* consumer(void* arg) {
    for (int i = 0; i < 100; i++) {
        pthread_mutex_lock(&mutex);
        while (count == 0) {
            pthread_cond_wait(&not_empty, &mutex);
        }
        int data = buffer[--count];
        pthread_cond_signal(&not_full);
        pthread_mutex_unlock(&mutex);
        printf("Consumed: %d\n", data);
    }
    return NULL;
}

int main() {
    pthread_t prod, cons;
    pthread_create(&prod, NULL, producer, NULL);
    pthread_create(&cons, NULL, consumer, NULL);

    pthread_join(prod, NULL);
    pthread_join(cons, NULL);

    return 0;
}

Benefits and Best Practices

Implementing the producer-consumer pattern improves application responsiveness and resource management. To ensure robustness:

  • Always initialize synchronization primitives properly.
  • Handle thread termination gracefully.
  • Use condition variables to avoid busy waiting.
  • Ensure shared data is protected with mutexes.

By following these guidelines, developers can create efficient and safe multithreaded applications using the producer-consumer pattern in C.