Classic problems (producer-consumer, readers-writers, dining philosophers) in Operating Systems - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to identify the classic problem where producers add items and consumers remove items from a shared buffer.

Operating Systems

The classic problem where producers and consumers share a buffer is called the [1] problem.

Drag options to blanks, or click blank then click option'

ADining Philosophers

BReaders-Writers

CProducer-Consumer

DSleeping Barber

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing the Producer-Consumer problem with the Dining Philosophers problem.

Choosing Readers-Writers which deals with access to shared data but not buffer sharing.

The Producer-Consumer problem involves producers generating data and placing it into a buffer, while consumers take data from the buffer. Synchronization is needed to avoid conflicts.

2fill in blank

medium

Complete the sentence to describe the main challenge in the Readers-Writers problem.

Operating Systems

The main challenge in the Readers-Writers problem is to allow multiple readers to access the data simultaneously while ensuring that [1] have exclusive access.

Drag options to blanks, or click blank then click option'

Awriters

Bconsumers

Cproducers

Dreaders

Attempts:

3 left

💡 Hint

Common Mistakes

Selecting readers instead of writers for exclusive access.

Confusing producers and consumers with readers and writers.

In the Readers-Writers problem, multiple readers can read the data at the same time, but writers must have exclusive access to prevent data inconsistency.

3fill in blank

hard

Fix the error in the description of the Dining Philosophers problem.

Operating Systems

In the Dining Philosophers problem, philosophers alternate between thinking and eating, but they must pick up [1] forks to eat.

Drag options to blanks, or click blank then click option'

Atwo

Bthree

Cone

Dfour

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing one fork, which is insufficient to eat.

Choosing more than two forks, which is incorrect.

Each philosopher needs two forks (one on each side) to eat, which can cause deadlock if all pick up one fork simultaneously.

4fill in blank

hard

Fill both blanks to complete the synchronization requirement in the Producer-Consumer problem.

Operating Systems

A producer must wait if the buffer is [1], and a consumer must wait if the buffer is [2].

Drag options to blanks, or click blank then click option'

Afull

Bempty

Clocked

Dunlocked

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up full and empty conditions.

Using locked/unlocked which are not the main buffer states.

Producers wait when the buffer is full to avoid overflow, and consumers wait when the buffer is empty to avoid underflow.

5fill in blank

hard

Fill all three blanks to complete the description of the Readers-Writers problem constraints.

Operating Systems

Multiple [1] can read simultaneously, but [2] must have exclusive access, and no [3] can read while a writer is writing.

Drag options to blanks, or click blank then click option'

Areaders

Bwriters

Dproducers

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing readers and writers roles.

Including producers which are unrelated to this problem.

Readers can read at the same time, writers need exclusive access, and readers cannot read while a writer is writing to prevent data inconsistency.

Practice

1. Which classic problem in operating systems involves multiple processes sharing a fixed number of resources and needing to avoid deadlock while accessing them?

easy

A. Sleeping Barber problem

B. Producer-Consumer problem

C. Readers-Writers problem

D. Dining Philosophers problem

Solution

1. Step 1: Understand the problem context

   The Dining Philosophers problem models philosophers sitting around a table sharing forks (resources) and needing to avoid deadlock.

2. Step 2: Match problem to description

   It specifically deals with multiple processes sharing limited resources and avoiding deadlock.

3. Final Answer:

   Dining Philosophers problem -> Option D

4. Quick Check:

   Deadlock with shared resources = Dining Philosophers [OK]

Hint: Deadlock with shared forks? Think Dining Philosophers [OK]

Common Mistakes:

• Confusing Producer-Consumer with resource deadlock
• Mixing Readers-Writers with resource sharing deadlock
• Choosing unrelated problems like Sleeping Barber

2. Which synchronization primitive is commonly used to solve the Producer-Consumer problem?

easy

A. Semaphore

B. Mutex

C. Barrier

D. Spinlock

Solution

1. Step 1: Identify synchronization needs in Producer-Consumer

   Producer-Consumer requires controlling access to a shared buffer and signaling availability.

2. Step 2: Match synchronization primitive

   Semaphores are used to count available slots and items, making them ideal here.

3. Final Answer:

   Semaphore -> Option A

4. Quick Check:

   Counting resources = Semaphore [OK]

Hint: Counting resources? Use Semaphore [OK]

Common Mistakes:

• Choosing Mutex which only locks/unlocks without counting
• Selecting Barrier which is for thread synchronization phases
• Confusing Spinlock with counting mechanism

3. Consider the Readers-Writers problem where multiple readers can read simultaneously but writers require exclusive access. If two readers and one writer request access at the same time, which scenario is correct?

medium

A. Both readers and writer access the resource simultaneously

B. Only one reader accesses the resource, writer waits

C. Both readers access simultaneously, writer waits

D. Writer accesses first, readers wait

Solution

1. Step 1: Recall Readers-Writers access rules

   Multiple readers can read at the same time, but writers need exclusive access.

2. Step 2: Apply rules to scenario

   When readers and writer request simultaneously, readers get access first, writer waits.

3. Final Answer:

   Both readers access simultaneously, writer waits -> Option C

4. Quick Check:

   Readers share, writer exclusive = readers first [OK]

Hint: Readers share access; writers wait for exclusivity [OK]

Common Mistakes:

• Allowing writer and readers simultaneously
• Restricting readers to one at a time
• Letting writer go first without readers finishing

4. In a solution to the Dining Philosophers problem, a programmer uses a simple lock for each fork but notices the system deadlocks. What is the most likely cause?

medium

A. All philosophers pick up their left fork simultaneously and wait for the right fork

B. Philosophers pick up forks randomly causing starvation

C. Philosophers release forks too early

D. Fork locks are not acquired atomically

Solution

1. Step 1: Understand deadlock in Dining Philosophers

   Deadlock occurs if all philosophers hold one fork and wait for the other indefinitely.

2. Step 2: Identify cause from options

   All picking left fork simultaneously and waiting for right fork causes circular wait and deadlock.

3. Final Answer:

   All philosophers pick up their left fork simultaneously and wait for the right fork -> Option A

4. Quick Check:

   Circular wait with forks = deadlock [OK]

Hint: Deadlock if all pick same fork first [OK]

Common Mistakes:

• Assuming random picking causes deadlock
• Thinking releasing forks early causes deadlock
• Ignoring atomicity of lock acquisition

5. You want to design a system where multiple producers generate data and multiple consumers process it, but the buffer size is limited. Which approach best prevents data loss and ensures synchronization?

hard

A. Allow producers to overwrite data if buffer is full

B. Use semaphores to track empty and full buffer slots with mutex for buffer access

C. Use only mutex locks for both producers and consumers

D. Use busy waiting loops for producers and consumers

Solution

1. Step 1: Identify synchronization needs

   Producers and consumers share a limited buffer; must avoid overwriting and race conditions.

2. Step 2: Choose synchronization method

   Semaphores count empty/full slots; mutex ensures exclusive buffer access, preventing data loss and race.

3. Final Answer:

   Use semaphores to track empty and full buffer slots with mutex for buffer access -> Option B

4. Quick Check:

   Counting slots + exclusive access = semaphores + mutex [OK]

Hint: Combine semaphores and mutex for safe buffer use [OK]

Common Mistakes:

• Using only mutex causes blocking but no counting
• Overwriting data loses information
• Busy waiting wastes CPU and causes inefficiency