# Bounded Buffer Problem in OS With Example

###### Greetings!
We have recently published 100+ articles on android tutorials with kotlin and java. If you need, you may visit Android Tutorial for beginners page. You can also check Kotlin Tutorial for beginners. Also, if you are interested in content writing, you can mail us at tutorialwing@gmail.com.

The following classical problem of synchronisation are used to test virtually every new proposed synchronisation algorithm.

• Bounded-Buffer Problem
• Dining-Philosophers Problem

#### Bounded Buffer Problem in OS

Bounded Buffer Problem in OS is a generalisation of the producer-consumer problem wherein access is controlled to a shared group of buffers of a limited size.

###### Problem Statement:

There is a buffer of n slots and each slot is capable of storing one unit of data. There are two processes running, producer and consumer, which are operating on the buffer.

Producer Consumer Problem

In this solution, the two counting semaphores full and empty keep track of the current number of full and empty buffer respectively (and initialised to 0 and N respectively). The binary semaphore (i.e. Mutex) controls access to the Critical Section. The producer and consumer processes are identical – one can think of the producer as producing full buffers, and the consumer producing empty buffers.

The structure of producer process:

```Do{
// produce an item in nextp Wait (empty);
Wait (Mutex);
// add the item to the buffer
Signal (Mutex);
Signal (full);
} while (True);
```

Explanation:
Producer first waits until there is at least one empty slot. Then, it decrements the empty semaphore. It is because there will now be one less empty slot. Since the producer is going to insert data in one of those slots. After performing the operation, the value of full is incremented because producer just filled the slot in the buffer.

The structure of consumer process:

```Do {
Wait (full);
Wait (Mutex);
//remove an item from buffer to next
Signal (Mutex);
Signal (empty);
// consume the item in next
} while (true);
```

Explanation:
The consumer waits until there is at least one full slot in the buffer. Then, it decrements the full semaphore because the number of occupied slots will be decreased by one. After the consumer completes its operation, the consumer completes the removal operation. Finally, the empty semaphore is initialized by 1. It is because the consumer has just removed data from an occupied slot. Now, slot is empty.

That’s end of tutorial on Bounded Buffer Problem in OS.

## Support Us

If you like Tutorialwing and would like to contribute, you can email an article on any educational topic at tutorialwing@gmail.com. We would love to publish your article. See your article on Tutorialwing and help others with your knowledge. Follow Facebook, LinkedIn, Google+, Twitter, Youtube for latest updates.
###### Greetings!
We have recently published 100+ articles on android tutorials with kotlin and java. If you need, you may visit Android Tutorial for beginners page. You can also check Kotlin Tutorial for beginners