Chapter 7: Synchronization

Examples

Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne ©2018
 Outline

 Explain the bounded-buffer synchronization problem

 Explain the readers-writers synchronization problem
 Explain and dining-philosophers synchronization problems
 Describe the tools used by Linux and Windows to solve
synchronization problems.
 Illustrate how POSIX and Java can be used to solve process
synchronization problems

Operating System Concepts – 10th Edition 7.2 Silberschatz, Galvin and Gagne ©2018
 Classical Problems of Synchronization
 Classical problems used to test newly-proposed synchronization
schemes(solutions)
• Bounded-Buffer Problem
• Readers and Writers Problem
• Dining-Philosophers Problem

 These problems are used for testing nearly every newly proposed
synchronization scheme

Operating System Concepts – 10th Edition 7.3 Silberschatz, Galvin and Gagne ©2018
 Bounded-Buffer Problem
 The Bounded-Buffer Problem (also known as the producer consumer
problem), is one of the classic problems of synchronization.
 There is a buffer of n slots and each slot is capable of storing one
unit of data
 There are two processes running, namely, Producer and Consumer,
which are operating on the buffer.
• The producer tries to insert data into the buffer
• The consumer to remove data from the buffer
• The producer must not insert data when the buffer is full
• The consumer must not remove data when the buffer is empty
• The producer and consumer should not insert and remove data
simultaneously

Operating System Concepts – 10th Edition 7.4 Silberschatz, Galvin and Gagne ©2018
 Solution to the Bounded-Buffer Problem using Semaphores

 We will use three semaphores:

• Semaphore mutex initialized to the value 1
 Recall, mutex is a binary semaphore which is used
to acquire and release the lock
• Semaphore full: A counting semaphore initialized to the value 0
 it stores the number of the filled slots in the buffer

• Semaphore empty initialized to the value n

 Empty is a counting semaphore whose initial value is the
number of the slots in the buffer, since, initially all slots are
empty.
 Empty stores the count of the empty slots in the buffer

Operating System Concepts – 10th Edition 7.5 Silberschatz, Galvin and Gagne ©2018
 Bounded Buffer Problem (Cont.)

 The structure of the producer process

while (true) {
...
/* produce an item in next_produced */
...
wait(empty); //wait until empty>0 and then decrement ‘empty’
wait(mutex); //acquire lock
...
/* add next produced data to the buffer */
...
signal(mutex); //release lock
signal(full); //increment ‘full’
}
Notes:
1. empty>0 if there exist an empty slot
Operating System Concepts – 10th Edition 7.6 Silberschatz, Galvin and Gagne ©2018
 Bounded Buffer Problem (Cont.)
 The structure of the consumer process

while (true) {
wait(full); //wait until full>0 and then decrement ‘full’
wait(mutex); //acquire lock
...
/* remove an item from buffer to next_consumed */
...
signal(mutex); //release lock
signal(empty); //increment empty
...
/* consume the item in next consumed */
...
}

Operating System Concepts – 10th Edition 7.7 Silberschatz, Galvin and Gagne ©2018
 Readers-Writers Problem
 Suppose that A data set (database or file )is shared among a number of
concurrent processes. Some of these processes may want only to
read the database, whereas others may want to update (that is,
read and write)

• Readers – only read the data set; they do not perform any updates
• Writers – can both read and write
 if two readers access the shared data simultaneously, there is no
problem. However, if a writer and some other process (either a
reader or a writer) access the database simultaneously, there may
be problems.

 To ensure that these difficulties do not arise, we require that the

writers
have exclusive access to the shared database while writing to the
database. This synchronization problem is referred to as the
readers–writers problem.
• Since it was originally stated, it has been used to test nearly
every new synchronization primitive.
  Main points in the first type of readers–write rs problem :
• If writer has started a writing process, then
 No additional or other writer can perform write function
 No reader is allowed to read
• If one or more readers are reading, then
 Other readers may read at the same time
 No writer may perform write function until all readers have
finished reading

Example1 Example2

Operating System Concepts – 10th Edition 7.9 Silberschatz, Galvin and Gagne ©2018
 Readers-Writers Problem (Cont.)
 In the solution to the first readers–writers problem, the reader processes
share the following data structures:
Data set
• Semaphore rw_mutex initialized to 1
 binary semaphore
 common to both reader and writer processes
 rw_mutex functions as a mutual exclusion semaphore for the
writers. It is also used by the first or last reader that enters or
exits the critical section. It is not used by readers that enter or
exit while other readers are in their critical sections.

• Semaphore mutex initialized to 1

 binary semaphore
 The mutex semaphore is used to ensure mutual exclusion when
the variable read_count is updated.
• Integer read_count initialized to 0
 is a counting semaphore
 keeps track of how many processes are currently reading the
 Readers-Writers Problem (Cont.)

 The structure of a writer process

while (true) {
wait(rw_mutex);
...
/* writing is performed */
...
signal(rw_mutex);
}

Operating System Concepts – 10th Edition 7.11 Silberschatz, Galvin and Gagne ©2018
 Readers-Writers Problem (Cont.)
 The structure of a reader process
while (true){
wait(mutex); //to write to read_count
read_count++;
if (read_count == 1) /* first reader */
wait(rw_mutex); //to prevent the writer to
enter
signal(mutex);
...
/* reading is performed */
...
wait(mutex);
read_ount--;
if (read_count == 0) /* last reader */
signal(rw_mutex);
signal(mutex);
}

Operating System Concepts – 10th Edition 7.12 Silberschatz, Galvin and Gagne ©2018
 Readers-Writers Problem Variations

 The solution in previous slide can result in a situation where

a writer process never writes. It is referred to as the “First
reader-writer” problem.
 The “Second reader-writer” problem is a variation of the
first reader-writer problem that state:
• Once a writer is ready to write, no “newly arrived
reader” is allowed to read.
 Both the first and second may result in starvation leading to
even more variations
 Problem is solved on some systems by kernel providing
reader-writer locks

Operating System Concepts – 10th Edition 7.13 Silberschatz, Galvin and Gagne ©2018
 Dining-Philosophers Problem
 N philosophers’ sit at a round table with a bowel of rice in the middle.

 They spend their lives alternating thinking and eating.

 They do not interact with their neighbors.
 Occasionally try to pick up 2 chopsticks (one at a time) to eat from bowl
• Need both to eat, then release both when done
 In the case of 5 philosophers, the shared data
 Bowl of rice (data set)
 Semaphore chopstick [5] initialized to 1

Operating System Concepts – 10th Edition 7.14 Silberschatz, Galvin and Gagne ©2018
 Dining-Philosophers Problem Algorithm
 Semaphore Solution
 The structure of Philosopher i :
while (true){
wait (chopstick[i] );
wait (chopStick[ (i + 1) % 5] );

/* eat for awhile */

signal (chopstick[i] );
signal (chopstick[ (i + 1) % 5] );

/* think for awhile */

}
 What is the problem with this algorithm?

Operating System Concepts – 10th Edition 7.15 Silberschatz, Galvin and Gagne ©2018
  The problem with this algorithm is that it can lead to deadlock in the
Dining Philosophers Problem.
 Deadlock HappensDeadlock Definition: Deadlock occurs when multiple
processes (philosophers) are waiting for resources (chopsticks), but none
can proceed because the resources they need are held by other
processes
 How Deadlock Occurs in This Algorithm:
• Each philosopher first waits for their left chopstick (wait(chopstick[i]))
• and then their right chopstick (wait(chopstick[(i + 1) % 5])).
• If all five philosophers simultaneously pick up their left chopstick,
none of them can proceed to pick up the right chopstick, because all
the chopsticks are already being held.
• As a result, all philosophers are stuck waiting indefinitely, causing a
deadlock.

Operating System Concepts – 10th Edition 7.16 Silberschatz, Galvin and Gagne ©2018