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

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

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

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

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

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

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

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

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

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

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

CSS 430: Operating Systems - Process Synchronization Race Condition LDA COUNT INCA STA COUNT Who will get there first? LDA COUNT DECA STA COUNT http://en.wikipedia.org/wiki/Race_condition CSS 430: Operating Systems - Process Synchronization

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Java Thread Transitions http://etutorials.org/cert/java+certification/Chapter+9.+Threads/9.5+Thread+Transitions/ CSS 430: Operating Systems - Process Synchronization

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

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

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

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

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

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

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

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

Bounded Buffer Problem CSS 430: Operating Systems - Process Synchronization

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

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

Bounded Buffer producer CSS 430: Operating Systems - Process Synchronization

Bounded Buffer consumer CSS 430: Operating Systems - Process Synchronization

Bounded Buffer factory CSS 430: Operating Systems - Process Synchronization

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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