Preemptive Context Switching: A process can’t anticipate context yields

Synchronization: Control the multi-threaded behavior when execution order is random

1. Critical Section: Enforce only one use of a shared resource at any time
2. Ordering: Control order of thread execution

Critical Section

Critical Section Requirements

Mutual Exclusion: Only one thread can execute in the critical section at a time

• Atomic: One action that either all complete or all fail

Fairness: When the critical section is free, all threads have fair chance to enter

• No starvation: A waiting thread will eventually enter

Performance: Overhead of lock & unlock CS is small wrt the actual task

Atomic Instructions

Hardware-provided Atomic Instruction

• test_and_set Record old value and set new value of a variable

Locks

Lock States: Locked - held, unlocked - free.

• lock() Blocking call that returns when the thread acquired the lock
• unlock() Release the lock

Spin Lock: while (test_and_set(*lock, 1) == 1);

• Busy waiting, starvation is possible

Sleep Lock: Use a spin-locked queue of waiting threads

Condition Variables

• Designed to solve the problem that condition checking are not atomic
• Wait for a specific condition to become true

Condition Variable Procedure:

1. Hold a lock while checking the shared condition
2. If the condition doesn’t satisfy, release lock and sleep
3. Re-acquire lock when waking up, do stuff.

Condition Variable Operations:

• pthread_cond_wait(cv, mutex) Release mutex, enqueue, sleep, re-acquire mutex
• pthread_cond_signal(cv) Wake one queued thread
• pthread_cond_broadcast(cv) Wake all queued threads
• All three functions are atomic!

Lost Wakeup Problem: Wait thread stuck on wait when signal happens before wait

• Solution: Check for condition before wait.

pthread_mutex_lock(mutex);
while(!condition) 
	pthread_cond_wait(cond, mutex);

// Do stuff

pthread_cond_signal(cond);
pthread_mutex_unlock(mutex);

Application Example

• Producer-Consumer structure: Two CVs, one signaling to P that buffer is empty, one signaling to C that the buffer has things.