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. Classic SynchronizationProblems
Representative of large class of problems
Used to test prospective solutions
Examples:
Bounded Buffer Problem
Readers and Writers Problem
Dining Philosophers Problem
CSS 430: Operating Systems - Process Synchronization

46. Bounded Buffer Problem
N buffers, each can hold one item
Solution: 3 semaphores
mutex (1): provide mutual exclusion
full (0): # of full buffers
empty (N): # of empty buffers
CSS 430: Operating Systems - Process Synchronization

47. Bounded Buffer Problem
CSS 430: Operating Systems - Process Synchronization

48. Bounded Buffer insert()
CSS 430: Operating Systems - Process Synchronization

49. Bounded Buffer remove()
CSS 430: Operating Systems - Process Synchronization

50. Bounded Buffer producer
CSS 430: Operating Systems - Process Synchronization

51. Bounded Buffer consumer
CSS 430: Operating Systems - Process Synchronization

52. Bounded Buffer factory
CSS 430: Operating Systems - Process Synchronization

53. Readers & Writers Problem
Data set shared among concurrent processes
Readers: only read the data set; do not modify it
Writers: can both read and write
Multiple readers can concurrently read
If one writer has access, no one else can have access
Problem: if reader(s) and writer(s) both want access, who gets to go (& when)?
CSS 430: Operating Systems - Process Synchronization

54. Readers & Writers Problem
Potential solutions?
CSS 430: Operating Systems - Process Synchronization

55. Readers & Writers Problem
Potential solutions:
New writers waits for readers
New readers wait for writers
Any problems with these “solutions”?
CSS 430: Operating Systems - Process Synchronization

56. Readers & Writers Problem
Potential solutions:
New writers waits for readers
New readers wait for writers
Any problems with these “solutions”?
starvation
Approach:
Database
Semaphore mutex (1): protect readerCount
Semaphore db (1): protect database updates
Integer readerCount (0): # of current readers
CSS 430: Operating Systems - Process Synchronization

57. Readers & Writers Problem
Interface for read-write locks
CSS 430: Operating Systems - Process Synchronization

58. Readers & Writers Problem
The structure of a writer
CSS 430: Operating Systems - Process Synchronization

59. Readers & Writers Problem
The structure of a reader
CSS 430: Operating Systems - Process Synchronization

60. Readers & Writers Problem
The database
CSS 430: Operating Systems - Process Synchronization

61. Readers & Writers Problem
Reader methods
CSS 430: Operating Systems - Process Synchronization

62. Readers & Writers Problem
Writer methods
CSS 430: Operating Systems - Process Synchronization

63. Dining Philosophers Problem
Philosopher’s Life: a cycle of
Thinking (no interaction)
Getting Hungry
Pick up one chopstick at a time
Eating
Eat
Put down both chopsticks
CSS 430: Operating Systems - Process Synchronization

64. Dining Philosophers Problem
Philosopher’s Life: a cycle of
Thinking (no interaction)
Getting Hungry
Pick up one chopstick at a time
Eating
Eat
Put down both chopsticks
Potential problems?
CSS 430: Operating Systems - Process Synchronization

65. Dining Philosophers Problem
Philosopher’s Life: a cycle of
Thinking (no interaction)
Getting Hungry
Pick up one chopstick at a time
Eating
Eat
Put down both chopsticks
Potential problems:
Starvation and Deadlock
CSS 430: Operating Systems - Process Synchronization

66. Dining Philosophers Problem
Philosopher’s Life: a cycle of
Thinking (no interaction)
Getting Hungry
Pick up one chopstick at a time
Eating
Eat
Put down both chopsticks
Potential problems:
Starvation and Deadlock
Edsger Wybe Dijkstra
CSS 430: Operating Systems - Process Synchronization

67. Dining Philosophers Problem
Potential solutions?
CSS 430: Operating Systems - Process Synchronization

68. Dining Philosophers Problem
Potential solutions (deadlock):
Restrict # of philosophers at table
Allow pickup only if both available
Asymmetry:
Odd philosopher pick up left, then right
Even philosopher pick up right, then left
Note: deadlock-free != starvation-free
Approach:
Bowl of rice (data set)
Semaphore chopStick [5] initialized to 1
CSS 430: Operating Systems - Process Synchronization

69. Dining Philosophers Problem
The structure of Philosopher i:
CSS 430: Operating Systems - Process Synchronization

70. Problems with Semaphores
mutex.release();
// critical // section
mutex.acquire();
mutex.acquire();
// critical // section
mutex.acquire();
// critical // section
// …
Might arise from
Honest programming error
Intentionally uncooperative programming
// …
// critical // section
mutex.release()
CSS 430: Operating Systems - Process Synchronization

71. CSS 430: Operating Systems - Process Synchronization
Monitors
A high-level abstraction that provides a convenient and effective mechanism for process synchronization
Only one process may be active within the monitor at a time
CSS 430: Operating Systems - Process Synchronization

72. CSS 430: Operating Systems - Process Synchronization
Syntax of a Monitor
CSS 430: Operating Systems - Process Synchronization

73. Schematic view of a Monitor
CSS 430: Operating Systems - Process Synchronization

74. CSS 430: Operating Systems - Process Synchronization
Condition Variables
Condition x, y;
Two operations on a condition variable:
x.wait () – a process that invokes the operation is suspended
x.signal () – resumes one of processes (if any) that invoked x.wait ()
CSS 430: Operating Systems - Process Synchronization

75. Monitor with Condition Variables
CSS 430: Operating Systems - Process Synchronization

76. Solution to Dining Philosophers
CSS 430: Operating Systems - Process Synchronization

77. Solution to Dining Philosophers
Each philosopher I invokes the operations takeForks(i) and returnForks(i) in the following sequence:
dp.takeForks (i)
EAT
dp.returnForks (i)
CSS 430: Operating Systems - Process Synchronization

78. CSS 430: Operating Systems - Process Synchronization
Java Synchronization
Java provides synchronization at the language-level
“Thread-safe”
Each Java object has an associated lock.
This lock is acquired by invoking a synchronized method.
This lock is released when exiting the synchronized method.
Threads waiting to acquire the object lock are placed in the entry set for the object lock.
CSS 430: Operating Systems - Process Synchronization

79. CSS 430: Operating Systems - Process Synchronization
Java Synchronization
When a thread invokes wait(): 1. It releases the object lock 2. Its state is set to Blocked 3. It is placed in the wait set for the object
When a thread invokes notify(): 1. A thread T from the wait set is selected 2. T is moved from the wait set to the entry set 3. The state of T is set to Runnable
CSS 430: Operating Systems - Process Synchronization

80. CSS 430: Operating Systems - Process Synchronization
Java Synchronization
CSS 430: Operating Systems - Process Synchronization

81. Java Synchronization – wait/notify
Synchronized remove() method – Correct!
CSS 430: Operating Systems - Process Synchronization

82. Java Synchronization - Bounded Buffer
CSS 430: Operating Systems - Process Synchronization

83. CSS 430: Operating Systems - Process Synchronization
Java Synchronization
The call to notify() selects an aribitrary thread from the wait set. It is possible the selected thread is in fact not waiting upon the condition for which it was notified.
The call notifyAll() selects all threads in the wait set and moves them to the entry set.
In general, notifyAll() is a more conservative strategy than notify().
CSS 430: Operating Systems - Process Synchronization

84. CSS 430: Operating Systems - Process Synchronization
Java Synchronization
notify() may not notify the correct thread!
CSS 430: Operating Systems - Process Synchronization

85. Java Synchronization - Readers-Writers
CSS 430: Operating Systems - Process Synchronization

86. Java Synchronization - Readers-Writers
CSS 430: Operating Systems - Process Synchronization

87. Java Synchronization - Readers-Writers
Methods called by writers
CSS 430: Operating Systems - Process Synchronization

88. CSS 430: Operating Systems - Process Synchronization
Java Synchronization
Rather than synchronizing an entire method, Block
synchronization allows blocks of code to be declared as
synchronized
CSS 430: Operating Systems - Process Synchronization

89. CSS 430: Operating Systems - Process Synchronization
Java Synchronization
Block synchronization using wait()/notify()
CSS 430: Operating Systems - Process Synchronization

90. Concurrency Features in Java 5
Prior to Java 5, the only concurrency features in Java were Using synchronized/wait/notify.
Beginning with Java 5, new features were added to the API:
Reentrant Locks
Semaphores
Condition Variables
CSS 430: Operating Systems - Process Synchronization

91. Concurrency Features in Java 5
Reentrant Locks
CSS 430: Operating Systems - Process Synchronization

92. Concurrency Features in Java 5
Semaphores
CSS 430: Operating Systems - Process Synchronization

93. Concurrency Features in Java 5
A condition variable is created by first creating a
ReentrantLock and invoking its newCondition() method:
Once this is done, it is possible to invoke the
await() and signal() methods
CSS 430: Operating Systems - Process Synchronization

94. Concurrency Features in Java 5
CSS 430: Operating Systems - Process Synchronization