Producer and Consumer with Threads and Semaphores in C

Prerequisites:

Before diving into the code, it is essential to have a basic understanding of C programming and some knowledge about threads and semaphores. If you are not familiar with these concepts, don't worry! I will explain everything step by step.

Components Involved:

To better understand the problem, let's go over the key components involved in the producer-consumer implementation:

Threads: Threads are independent sequences of execution within a process. In this scenario, we will use multiple threads, with one acting as the producer and another as the consumer.
Semaphores: Semaphores are synchronization constructs used to control access to shared resources in a concurrent program. We'll utilize two semaphores, one to represent empty slots in the buffer (empty_slots) and the other to represent filled slots in the buffer (filled_slots).
Buffer: The buffer is a shared data structure that stores data items produced by the producer and consumed by the consumer. It should be implemented as a circular queue, with a size large enough to hold a certain number of data items.

Code Implementation:

Let's now delve into the code implementation of the producer-consumer problem using threads and semaphores in C.

#include 
#include 
#include 
#include 
#define BUFFER_SIZE 5 // Size of the buffer
int buffer[BUFFER_SIZE];
int buffer_index = 0; // Index to keep track of the next empty slot in the buffer
sem_t empty_slots; // Semaphore to track the number of empty slots in the buffer
sem_t filled_slots; // Semaphore to track the number of filled slots in the buffer
// Function prototypes
void *producer(void *arg);
void *consumer(void *arg);
void insert_item(int item);
int remove_item();
int main() {
    // Initialize the semaphores
    sem_init(&empty_slots, 0, BUFFER_SIZE);
    sem_init(&filled_slots, 0, 0);
    // Create producer and consumer threads
    pthread_t producer_thread, consumer_thread;
    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);
    // Wait for threads to finish
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);
    // Destroy the semaphores
    sem_destroy(&empty_slots);
    sem_destroy(&filled_slots);
    return 0;
}
// Producer thread function
void *producer(void *arg) {
    int produced_item;
    while (1) {
        // Simulate producing an item (you can replace this with actual data generation)
        produced_item = rand() % 100;
        // Wait for an empty slot in the buffer
        sem_wait(&empty_slots);
        // Insert the produced item into the buffer
        insert_item(produced_item);
        // Signal that a slot in the buffer is filled
        sem_post(&filled_slots);
        printf("Produced item: %d\n", produced_item);
    }
    return NULL;
}
// Consumer thread function
void *consumer(void *arg) {
    int consumed_item;
    while (1) {
        // Wait for a filled slot in the buffer
        sem_wait(&filled_slots);
        // Remove the item from the buffer
        consumed_item = remove_item();
        // Signal that a slot in the buffer is now empty
        sem_post(&empty_slots);
        printf("Consumed item: %d\n", consumed_item);
    }
    return NULL;
}
// Function to insert an item into the buffer
void insert_item(int item) {
    buffer[buffer_index] = item;
    buffer_index = (buffer_index + 1) % BUFFER_SIZE;
}
// Function to remove an item from the buffer
int remove_item() {
    int item = buffer[(buffer_index + BUFFER_SIZE - 1) % BUFFER_SIZE];
    buffer_index = (buffer_index + BUFFER_SIZE - 1) % BUFFER_SIZE;
    return item;
}

Explanation for Each Block of Code:

We include the necessary headers and define constants like the buffer size and function prototypes.

The global variables are defined, including the buffer, buffer_index (to track the next empty slot), and the semaphores, empty_slots, and filled_slots.
The main() function initializes the semaphores, creates the producer and consumer threads, waits for their completion using pthread_join, and then destroys the semaphores before exiting.
The producer() function is the entry point for the producer thread. It runs in an infinite loop (you may want to add termination conditions based on your specific use case). In each iteration, it produces an item (here, we generate a random integer) and then proceeds to insert it into the buffer. Before inserting, it waits for an empty slot (decrementing the empty_slots semaphore). After insertion, it signals that a slot has been filled (increments the filled_slots semaphore).
The consumer() function is the entry point for the consumer thread. It also runs in an infinite loop. In each iteration, it waits for a filled slot in the buffer (decrementing the filled_slots semaphore) to consume an item. After consuming, it signals that a slot in the buffer is now empty (increments the empty_slots semaphore).
The insert_item() and remove_item() functions are utility functions to add an item to the buffer and remove an item from the buffer, respectively.

Conclusion:

The producer-consumer problem is a fundamental synchronization challenge in concurrent programming. Through this article, we have explored a C implementation of the producer-consumer problem using threads and semaphores. Understanding this example will provide you with a solid foundation for tackling more complex synchronization problems in your programming journey.

Explore Producer-Consumer Synchronization with Threads and Semaphores in C

Prerequisites:

Components Involved:

Code Implementation:

Explanation for Each Block of Code:

Conclusion: