1. Lecture 9: Process Synchronization
Joe McCarthy
CSS 430: Operating Systems - Process Synchronization

2. Chapter 6: Process Synchronization
Background
The Critical-Section Problem
Peterson’s Solution
Synchronization Hardware
Semaphores
Classic Problems of Synchronization
Monitors
Synchronization Examples
Atomic Transactions
Material derived, in part, from Operating Systems Concepts with Java, 8th Ed. © 2009 Silberschatz, Galvin & Gagne
CSS 430: Operating Systems - Process Synchronization

3. Circular Buffer (Queue)
CSS 430: Operating Systems - Process Synchronization

4. Producer-Consumer Problem
public void insert () { // Producer
E item;
while (count == BUFFER_SIZE)
; // busy wait
buffer[in] = item;
in = (in + 1) % BUFFER_SIZE;
++count; }
public E remove() { // Consumer
E item;
while (count == 0)
; // busy wait
item = buffer[out];
out = (out + 1) % BUFFER_SIZE;
--count;
return item; }
CSS 430: Operating Systems - Process Synchronization

5. Producer-Consumer Problem
public void insert () { // Producer
E item;
while (count == BUFFER_SIZE)
; // busy wait
buffer[in] = item;
in = (in + 1) % BUFFER_SIZE;
++count; }
LDA COUNT INCA STA COUNT
public E remove() { // Consumer
E item;
while (count == 0)
; // busy wait
item = buffer[out];
out = (out + 1) % BUFFER_SIZE;
--count;
return item; }
LDA COUNT DECA STA COUNT
CSS 430: Operating Systems - Process Synchronization

6. Producer-Consumer Problem
LDA COUNT INCA STA COUNT
import java.util.Date;
public class Factory {
public static void main( String[] args ) {
// create the message queue
Channel<Date> queue = new MessageQueue<Date>();
// create the producer and consumer threads
Thread producer = new Thread( new Producer(queue) );
Thread consumer
= new Thread( new Consumer(queue) );
// start the threads
producer.start();
consumer.start(); }
LDA COUNT DECA STA COUNT
[from Chapter 3: Processes]
CSS 430: Operating Systems - Process Synchronization

7. Producer-Consumer Problem
LDA COUNT INCA STA COUNT
import java.util.Date;
public class Factory {
public static void main( String[] args ) {
// create the message queue
Channel<Date> queue = new MessageQueue<Date>();
Integer count = new Integer( 0 );
// create the producer and consumer threads
Thread producer = new Thread( new Producer(queue, count) );
Thread consumer
= new Thread( new Consumer(queue, count) );
// start the threads
producer.start();
consumer.start(); }
LDA COUNT DECA STA COUNT
[from Chapter 3: Processes]
CSS 430: Operating Systems - Process Synchronization

8. Producer-Consumer Problem
LDA COUNT INCA STA COUNT
LDA COUNT DECA STA COUNT
CSS 430: Operating Systems - Process Synchronization

9. Producer-Consumer Problem
LDA COUNT INCA STA COUNT
producer
consumer
LDA COUNT INCA
LDA COUNT DECA
LDA COUNT DECA STA COUNT
STA COUNT
STA COUNT
CSS 430: Operating Systems - Process Synchronization

10. Producer-Consumer Problem
LDA COUNT INCA STA COUNT
producer
consumer
LDA COUNT INCA
LDA COUNT DECA
LDA COUNT DECA STA COUNT
STA COUNT
STA COUNT
What’s the value of count?
CSS 430: Operating Systems - Process Synchronization

11. CSS 430: Operating Systems - Process Synchronization
Race Condition
LDA COUNT INCA STA COUNT
Who will get there first?
LDA COUNT DECA STA COUNT
CSS 430: Operating Systems - Process Synchronization

12. CSS 430: Operating Systems - Process Synchronization
Race Condition
LDA COUNT INCA STA COUNT
Who will get there first?
LDA COUNT DECA STA COUNT
CSS 430: Operating Systems - Process Synchronization

13. CSS 430: Operating Systems - Process Synchronization
Critical Section
Definition: segment of code that accesses a shared resource
Problem: multiple processes have concurrent access to shared resource
Solution: prevent multiple processes from having concurrent access to shared resource
No two processes are executing in their critical section at the same time.
CSS 430: Operating Systems - Process Synchronization

14. CSS 430: Operating Systems - Process Synchronization
General Structure
Protocol:
Request entry to critical section
Execute critical section
Exit critical section
Do other stuff (remainder section)
CSS 430: Operating Systems - Process Synchronization

15. Solution to Critical-Section Problem
Mutual Exclusion - If process Pi is executing in its critical section, then no other processes can be executing in their critical sections.
Progress - If no process is executing in its critical section and there exist some processes that wish to enter their critical section, then the selection of the processes that will enter the critical section next cannot be postponed indefinitely.
Bounded Waiting - A bound must exist on the number of times that other processes are allowed to enter their critical sections after a process has made a request to enter its critical section and before that request is granted.
Assume that each process executes at a nonzero speed
No assumption concerning relative speed of the N processes
CSS 430: Operating Systems - Process Synchronization

16. CSS 430: Operating Systems - Process Synchronization
A simple solution
Assume:
2 processes, P0 & P1
2 shared variables
int turn; // if 0, P0’s turn; if 1, P1’s turn
boolean flag[2]; // if flag[i], Pi wants to enter CS
LOAD (LDA) & STORE (STA) are atomic
i.e., assignment statements are indivisible
How would you implement this?
CSS 430: Operating Systems - Process Synchronization

17. CSS 430: Operating Systems - Process Synchronization
Peterson’s Solution
while ( true ) {
flag[i] = true;
turn = j;
while ( flag[j] && turn == j )
; // busy wait
// critical section
// …
flag[i] = false;
// remainder section }
entry section
exit section
CSS 430: Operating Systems - Process Synchronization

18. CSS 430: Operating Systems - Process Synchronization
Peterson’s Solution
while ( true ) {
flag[i] = true;
turn = j;
while ( flag[j] && turn == j )
; // busy wait
// critical section
// …
flag[i] = false;
// remainder section }
entry section
exit section
Software-based solution
CSS 430: Operating Systems - Process Synchronization

19. Synchronization via Locks
Hardware-based solution
CSS 430: Operating Systems - Process Synchronization

20. Synchronization via Hardware
Disable interrupts during CS
Preempt preemption
Feasible on uniprocessors
What about multiprocessors?
Atomic machine instructions
Indivisible (non-interruptable)
Examples:
Test & modify word
Swap two words
CSS 430: Operating Systems - Process Synchronization

21. S/W abstraction for H/W Synch.
public class HardwareData {
private boolean value = false;
public HardwareData( boolean initialValue ) {
this.value = initialValue; }
public boolean get() {
return value;
public void set( boolean newValue ) {
this.value = newValue;
public boolean getAndSet( boolean newValue ) {
boolean oldValue = this.get();
this.set( newValue );
return oldValue;
public void swap( HardwareData other ) {
boolean temp = this.get();
this.set( other.get() );
other.set( temp );
/usr/apps/CSS430/examples/os-book/ch6/hardware
CSS 430: Operating Systems - Process Synchronization

22. CSS 430: Operating Systems - Process Synchronization
Using getAndSet()
public class Worker1 implements Runnable {
private String name;
private HardwareData mutex;
public Worker1( String name, HardwareData mutex ) {
this.name = name;
this.mutex = mutex; }
public void run() {
// mutex initialized when Worker instantiated
while ( true ) {
System.out.println( name + " wants to enter CS" );
while ( mutex.getAndSet( true ) )
Thread.yield();
System.out.println( name + " is in critical section" );
MutualExclusionUtilities.criticalSection( name );
System.out.println( name + " is out of critical section" );
mutex.set( false );
MutualExclusionUtilities.remainderSection( name );
Do you [fore]see any problems?
/usr/apps/CSS430/examples/os-book/ch6/hardware
CSS 430: Operating Systems - Process Synchronization

23. Using getAndSet() Does this enforce mutual exclusion?
public class Worker1 implements Runnable {
private String name;
private HardwareData mutex;
public Worker1( String name, HardwareData mutex ) {
this.name = name;
this.mutex = mutex; }
public void run() {
// mutex initialized when Worker instantiated
while ( true ) {
System.out.println( name + " wants to enter CS" );
while ( mutex.getAndSet( true ) )
Thread.yield();
System.out.println( name + " is in critical section" );
MutualExclusionUtilities.criticalSection( name );
System.out.println( name + " is out of critical section" );
mutex.set( false );
MutualExclusionUtilities.remainderSection( name );
Does this enforce mutual exclusion?
Do you [fore]see any problems?
/usr/apps/CSS430/examples/os-book/ch6/hardware
CSS 430: Operating Systems - Process Synchronization

24. CSS 430: Operating Systems - Process Synchronization
Using swap()
public class Worker2 implements Runnable {
private String name;
private HardwareData mutex;
public Worker2( String name, HardwareData mutex ) {
this.name = name;
this.mutex = mutex; }
public void run() {
key = new HardwareData( true );
while ( true ) {
System.out.println( name + " wants to enter CS" );
key.set( true );
do { mutex.swap( key ); } while ( key.get() );
System.out.println( name + " is in critical section" );
MutualExclusionUtilities.criticalSection( name );
System.out.println( name + " is out of critical section" );
mutex.set( false );
MutualExclusionUtilities.remainderSection( name );
/usr/apps/CSS430/examples/os-book/ch6/hardware
CSS 430: Operating Systems - Process Synchronization

25. CSS 430: Operating Systems - Process Synchronization
Using swap()
public class Worker2 implements Runnable {
private String name;
private HardwareData mutex;
public Worker2( String name, HardwareData mutex ) {
this.name = name;
this.mutex = mutex; }
public void run() {
key = new HardwareData( true );
while ( true ) {
System.out.println( name + " wants to enter CS" );
key.set( true );
do { mutex.swap( key ); } while ( key.get() );
System.out.println( name + " is in critical section" );
MutualExclusionUtilities.criticalSection( name );
System.out.println( name + " is out of critical section" );
mutex.set( false );
MutualExclusionUtilities.remainderSection( name );
Do you [fore]see any new problems?
/usr/apps/CSS430/examples/os-book/ch6/hardware
CSS 430: Operating Systems - Process Synchronization

26. Using swap() Does not work & play well w/ others
public class Worker2 implements Runnable {
private String name;
private HardwareData mutex;
public Worker2( String name, HardwareData mutex ) {
this.name = name;
this.mutex = mutex; }
public void run() {
key = new HardwareData( true );
while ( true ) {
System.out.println( name + " wants to enter CS" );
key.set( true );
do { mutex.swap( key ); } while ( key.get() );
System.out.println( name + " is in critical section" );
MutualExclusionUtilities.criticalSection( name );
System.out.println( name + " is out of critical section" );
mutex.set( false );
MutualExclusionUtilities.remainderSection( name );
Does not work & play well w/ others
Do you [fore]see any new problems?
/usr/apps/CSS430/examples/os-book/ch6/hardware
CSS 430: Operating Systems - Process Synchronization

27. Using swap() Rewrite using while & yield()
public class Worker2 implements Runnable {
private String name;
private HardwareData mutex;
public Worker2( String name, HardwareData mutex ) {
this.name = name;
this.mutex = mutex; }
public void run() {
key = new HardwareData( true );
while ( true ) {
System.out.println( name + " wants to enter CS" );
key.set( true );
while ( key.get() ) { Thread.yield(); mutex.swap( key ); }
System.out.println( name + " is in critical section" );
MutualExclusionUtilities.criticalSection( name );
System.out.println( name + " is out of critical section" );
mutex.set( false );
MutualExclusionUtilities.remainderSection( name );
Rewrite using while & yield()
/usr/apps/CSS430/examples/os-book/ch6/hardware
CSS 430: Operating Systems - Process Synchronization

28. CSS 430: Operating Systems - Process Synchronization
Using AtomicBoolean
public class Worker1a implements Runnable {
private String name;
private AtomicBoolean mutex;
public Worker1a( String name, AtomicBoolean mutex ) {
this.name = name;
this.mutex = mutex; }
public void run() {
// mutex initialized when Worker instantiated
while ( true ) {
System.out.println( name + " wants to enter CS" );
while ( mutex.getAndSet( true ) )
Thread.yield();
System.out.println( name + " is in critical section" );
MutualExclusionUtilities.criticalSection( name );
System.out.println( name + " is out of critical section" );
mutex.set( false );
MutualExclusionUtilities.remainderSection( name );
/usr/apps/CSS430/examples/os-book/ch6/hardware
CSS 430: Operating Systems - Process Synchronization

29. AtomicBooleanFactory
import java.util.concurrent.atomic.AtomicBoolean;
public class AtomicBooleanFactory {
public static void main( String args[] ) {
AtomicBoolean lock = new AtomicBoolean( false );
Thread[] worker = new Thread[5];
for ( int i = 0; i < 5; i++ ) {
worker[i] = new Thread(
new Worker1a(
String.format( "worker %d", i ),
lock ) );
worker[i].start(); }
/usr/apps/CSS430/examples/os-book/ch6/hardware
CSS 430: Operating Systems - Process Synchronization

30. CSS 430: Operating Systems - Process Synchronization
Semaphores
Software-based synchronization mechanism
Avoids busy waiting
Semaphore S – integer variable
Value  # of shared resources available
Binary (1), aka mutex locks, or Counting (> 1)
[Only] 2 indivisible operations modify S:
acquire() & release()
Originally:
P() [proberen, “test”] & V() [verhogen, “increment”]
CSS 430: Operating Systems - Process Synchronization

31. CSS 430: Operating Systems - Process Synchronization
Semaphores
Indivisible testing & modification of value
CSS 430: Operating Systems - Process Synchronization

32. Semaphores for Synchronization
Critical section protection, other synchronization
Process P0:
Process P1:
CSS 430: Operating Systems - Process Synchronization

33. getAndSet vs. Semaphores
private AtomicBoolean mutex; …
while ( mutex.getAndSet( true ) )
Thread.yield();
// critical section
mutex.set( false );
// remainder section
CSS 430: Operating Systems - Process Synchronization

34. Busy waiting vs. Blocking
CSS 430: Operating Systems - Process Synchronization

35. Busy waiting vs. Blocking
CSS 430: Operating Systems - Process Synchronization

36. CSS 430: Operating Systems - Process Synchronization
Blocking & Waking up
CSS 430: Operating Systems - Process Synchronization

37. A Semaphore Implementation
public class Semaphore {
private int value;
public Semaphore( int initialValue ) {
this.value = initialValue; }
public synchronized void acquire() {
while ( value <= 0 ) {
try {
wait();
} catch ( InterruptedException e ) {
value--;
public synchronized void release() {
++value;
notify();
/usr/apps/CSS430/examples/os-book/ch6/semaphores
CSS 430: Operating Systems - Process Synchronization

38. Java Thread Transitions
CSS 430: Operating Systems - Process Synchronization

39. AtomicBoolean vs. Semaphore
public class Worker1a implements Runnable {
private String name;
private AtomicBoolean mutex;
public Worker1a( String name, AtomicBoolean mutex ) {
this.name = name;
this.mutex = mutex; }
public void run() {
// mutex initialized when Worker instantiated
while ( true ) {
System.out.println( name + " wants to enter CS" );
while ( mutex.getAndSet( true ) )
Thread.yield();
System.out.println( name + " is in critical section" );
MutualExclusionUtilities.criticalSection( name );
System.out.println( name + " is out of critical section" );
mutex.set( false );
MutualExclusionUtilities.remainderSection( name );
/usr/apps/CSS430/examples/os-book/ch6/hardware
CSS 430: Operating Systems - Process Synchronization

40. CSS 430: Operating Systems - Process Synchronization
A Semaphore Example
import java.util.concurrent.Semaphore;
public class Worker implements Runnable {
private Semaphore sem;
private String name;
public Worker( String name, Semaphore sem ) {
this.name = name;
this.sem = sem; }
public void run() {
while ( true ) {
sem.acquire();
System.out.println( name + " is in critical section" );
MutualExclusionUtilities.criticalSection( name );
System.out.println( name + " is out of critical section" );
sem.release();
MutualExclusionUtilities.remainderSection( name );
/usr/apps/CSS430/examples/os-book/ch6/semaphores
CSS 430: Operating Systems - Process Synchronization

41. CSS 430: Operating Systems - Process Synchronization
A Semaphore Example
import java.util.concurrent.Semaphore;
public class SemaphoreFactory {
public static void main( String args[] ) {
Semaphore sem = new Semaphore( 1 );
Thread[] bee = new Thread[5];
for ( int i = 0; i < 5; i++ )
bee[i] =
new Thread(
new Worker(
String.format( "worker %d", i),
sem ) );
bee[i].start(); }
/usr/apps/CSS430/examples/os-book/ch6/semaphores
CSS 430: Operating Systems - Process Synchronization

42. CSS 430: Operating Systems - Process Synchronization
Deadlock & Starvation
Deadlock – two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes
Let S and Q be two semaphores initialized to 1
Starvation – indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended.
CSS 430: Operating Systems - Process Synchronization

43. CSS 430: Operating Systems - Process Synchronization
Priority Inversion
3 processes, 3 priorities: L < M < H
Scenario:
L has acquired shared resource R
H wants to acquire R
M preempts L (which still has R)
M has effectively preempted H
Solution?
CSS 430: Operating Systems - Process Synchronization

44. CSS 430: Operating Systems - Process Synchronization
Priority Inversion
3 processes, 3 priorities: L < M < H
Scenario:
L has acquired shared resource R
H wants to acquire R
M preempts L (which still has R)
M has effectively preempted H
Solution:
Priority-inheritance protocol
CSS 430: Operating Systems - Process Synchronization

45. CSS 430: Operating Systems - Process Synchronization
Next Time:
Background
The Critical-Section Problem
Peterson’s Solution
Synchronization Hardware
Semaphores
Classic Problems of Synchronization
Monitors
Synchronization Examples
Atomic Transactions
Material derived, in part, from Operating Systems Concepts with Java, 8th Ed. © 2009 Silberschatz, Galvin & Gagne
CSS 430: Operating Systems - Process Synchronization

46. CSS 430: Operating Systems - Process Synchronization
this.suspend();
CSS 430: Operating Systems - Process Synchronization