Producer Consumer Problem in C

Concurrency is an important topic in concurrent programming since it allows us to completely understand how the systems work. Among the several challenges faced by practitioners working with these systems, there is a major synchronization issue which is the producer-consumer problem. In this article, we will discuss this problem and look at possible solutions based on C programming.

What is the Producer-Consumer Problem?

The producer-consumer problem is an example of a multi-process synchronization problem. The problem describes two processes, the producer and the consumer that share a common fixed-size buffer and use it as a queue.

• The producer’s job is to generate data, put it into the buffer, and start again.
• At the same time, the consumer is consuming the data (i.e., removing it from the buffer), one piece at a time.

What is the Actual Problem?

Given the common fixed-size buffer, the task is to make sure that the producer can't add data into the buffer when it is full and the consumer can't remove data from an empty buffer. Accessing memory buffers should not be allowed to producers and consumers at the same time.

Solution of Producer-Consumer Problem

The producer is to either go to sleep or discard data if the buffer is full. The next time the consumer removes an item from the buffer, it notifies the producer, who starts to fill the buffer again. In the same manner, the consumer can go to sleep if it finds the buffer to be empty. The next time the producer transfer data into the buffer, it wakes up the sleeping consumer.

Note: An inadequate solution could result in a deadlock where both processes are waiting to be awakened.

Approach: The idea is to use the concept of parallel programming and Critical Section to implement the Producer-Consumer problem in C language using OpenMP. 

Below is the implementation of the above approach:

Output:

Problem for Practice

Question 1: Processes P1 and P2 have a producer-consumer relationship, communicating by the use of a set of shared buffers.

P1: repeat
 Obtain an empty buffer
 Fill it
 Return a full buffer
 forever
P2: repeat
 Obtain a full buffer
 Empty it
 Return an empty buffer
 forever

Increasing the number of buffers is likely to do which of the following? [ISRO CS 2018]

I. Increase the rate at which requests are satisfied (throughput).

II. Decrease the likelihood of deadlock .

III. Increase the ease of achieving a correct implementation.

(A) Ill only

(B) II only

(C) I only 

(D) II and III only

Solution: Increasing the size of the memory allocated to the process or increasing buffer requirement does not affect the likelihood of the
deadlock and doesn't affect the implementation of the system. It can increase the rate at which the requests are satisfied(throughput) larger 
will be the size of the buffer, larger will be throughput. Therefore the only statement correct is I. Hence option (C) is correct.