Mahmoud Abas, Full-Stack Software Engineer & AI

Operating Systems 1 (2025-2026) - Operating System 1 Week06 Lab

In the print dialog, choose "Save as PDF" as the destination.

Operating Systems 1 - Lab

Synchronization and Deadlock in C#

Why shared data needs protecting, the four ways C# protects it, and the classic problem where the protection itself hangs.

Multi-Core, Multi-Processing, Multi-Tasking

Term	What it means
Dual / Quad core	a machine with two or four physical processors
Multi-processing	one processor containing several arithmetic and logic units
Multi-tasking	one processor switching between processes by a context switch

A context switch stores the state of a process so it can be reloaded and resume later

i7 Against i5 and i3, and Clock Speed

The numbers 7, 5 and 3 do not indicate core count
They reflect overall processor performance, clock speed included
Clock speed counts CPU cycles per second in GHz
So a 3.2 GHz CPU executes 3.2 billion cycles every second
Sometimes several instructions finish in one cycle
And sometimes one instruction spans several cycles

The Multithreading Problem

C# runs code in parallel through multithreading
Threads share data by holding a common reference to the same object
Reading and writing that data without coordination makes results unpredictable
The answer is thread synchronization

Ticket Reservation: The Problem

A shared Tickets variable holds the number left to sell
Two threads each try to sell one at the same moment
Both reach the same variable
And without protection, both sell the same ticket

Ticket Reservation: Interleaved Execution

text

Thread 1                    Thread 2
1. If (Tickets > 0)
2a. Register = Tickets
2b. Decrement register
2c. Tickets = register
3. Print "Tickets"
                             1. If (Tickets > 0)
                             2a. Register = Tickets
                             2b. Decrement register
                             2c. Tickets = register
                             3. Print "Tickets"

The Critical Section

A critical section: A segment of code where shared data is accessed. It needs an atomic action, so exactly one thread executes it at a time.

Synchronization is what makes that section atomic
C# offers four ways: lock, Mutex, Monitor and Semaphore

Lock, Mutex and Monitor

Mechanism	How it is acquired and released
`lock`	exclusive locking, the language keyword
`Mutex`	also exclusive but slower, via `WaitOne` and `ReleaseMutex`
`Monitor`	exclusive as well, via `Monitor.Enter` and `Monitor.Exit`

All three guarantee that only one thread runs the critical section at any moment

Semaphore

A semaphore admits a specified number of threads at once
Capacity 1 makes it a binary semaphore, behaving like a lock or mutex
Capacity above 1 makes it a general semaphore, letting several through together
Pick a lock, mutex or monitor for exclusive access
And a general semaphore when a limited pool of concurrent access is acceptable

Bounded Buffer: Producer and Consumer

The shared buffer behaves like a stack with a fixed capacity
The producer adds items to it
The consumer removes them, but only after they have been produced
A completely full buffer stops the producer from producing another item
The two must never touch the buffer at the same time
A general semaphore tracking free and full slots is what enforces that

Deadlock

Deadlock: A process waiting because another waiting process holds the resource it needs. Each side then waits for the other forever.

It is the direct risk of poorly coordinated synchronization
And its classic illustration is the dining philosophers problem

The Dining Philosophers Problem

Philosopher takes the right fork

Waits for the left fork

The neighbour already holds it

Nobody can ever eat

Five philosophers sit at a table with one fork between each pair
Eating needs both the left and the right fork
So if all five take their right fork at once, all five wait forever

Avoiding Deadlock

Seat at most four philosophers, so one can always obtain both forks
Break the symmetry: even-numbered take right then left, odd-numbered take left then right
Or let a philosopher pick up forks only when both are free at the same time

Key Takeaways

Threads share data through common object references, which is exactly why synchronization is needed
A critical section must run atomically, and lock, Mutex, Monitor and Semaphore are the four ways to enforce it
The first three give exclusive access, while a general semaphore admits a fixed number at once
The bounded-buffer pattern needs synchronization so producer and consumer never touch the buffer together
Deadlock is processes waiting on each other's held resources forever
It is avoided by limiting contention, breaking symmetry, or acquiring every needed resource at once

Open this lesson

Mahmoud AbasOperating System 1 Week06 Lab

Term

What it means

Dual / Quad core

a machine with two or four physical processors

Multi-processing

one processor containing several arithmetic and logic units

Multi-tasking

one processor switching between processes by a context switch

Thread 1 Thread 2 1. If (Tickets > 0) 2a. Register = Tickets 2b. Decrement register 2c. Tickets = register 3. Print "Tickets" 1. If (Tickets > 0) 2a. Register = Tickets 2b. Decrement register 2c. Tickets = register 3. Print "Tickets"

Mechanism

How it is acquired and released

lock

exclusive locking, the language keyword

Mutex

also exclusive but slower, via WaitOne and ReleaseMutex

Monitor

exclusive as well, via Monitor.Enter and Monitor.Exit