count++ is load–increment–store; interleaving these steps from two processes can lose an update.

Race condition: the result depends on the order in which processes access shared data.

Critical section: the code that touches shared data. Structure: entry section, critical section, exit section, remainder section.

Requirements: Mutual exclusion (one at a time), Progress (no needless waiting when the CS is free), Bounded waiting (no starvation).

Memory trick M-P-B: Mutual exclusion, Progress, Bounded waiting.

Peterson’s solution (2 processes): shared turn and flag[2]. Pᵢ sets flag[i] = true, turn = j, then waits while flag[j] && turn == j.

Hardware support: atomic (uninterruptible) instructions such as test_and_set and compare_and_swap.

test_and_set returns the old value and sets the lock to true, in one atomic step.

Semaphore S: integer accessed only by wait() (P: decrement, block if < 0) and signal() (V: increment, wake one).

Binary semaphore (0/1) = mutex lock. Counting semaphore controls access to N instances; initialize it to N.

Busy waiting (spinlock) wastes CPU; better implementation blocks the process on the semaphore’s waiting list.

Bounded buffer: mutex = 1, full = 0, empty = n. Producer: wait(empty); wait(mutex); … signal(mutex); signal(full).

Trap Swapping the order to wait(mutex); wait(empty) can deadlock when the buffer is full.

Semaphore misuse: signal before wait, wait twice, or forgetting one → broken mutual exclusion or deadlock.

Monitor: high-level construct; only one process active inside at a time.

Condition variables: x.wait() suspends the caller; x.signal() resumes one waiting process (no effect if none).