Mahmoud Abas, Full-Stack Software Engineer & AI

Operating Systems 1 (2025-2026) - Operating System Lab - Week 7

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

Operating Systems 1 - Week 07 Lab

Threading and Concurrency in C#

Creating threads, the race conditions they cause, the lock that prevents them, and the ThreadPool that reuses them.

Program, Process and Thread

Program

static instructions on disk

Process

owns memory and resources

Thread

smallest unit of execution

A program holds code and data but does not execute by itself
A process is a running instance with its own memory and at least one thread
Threads in one process share memory and resources
But each keeps its own program counter, stack and register set

Creating and Starting a Thread

csharp

Thread myThread = new Thread(PrintNumbers);
myThread.Start();
myThread.Join();   // wait for it to finish

Start begins execution, and Join blocks the caller until it ends. That pair is the fork-join pattern.

Synchronous Compared With Asynchronous

Style	How the work runs
Synchronous	sequentially, each operation finishing before the next begins
Asynchronous	concurrently, a later one starting before an earlier one finishes

Parallel work wins on I/O-bound or independent tasks, because the work overlaps instead of queuing

The Ping-Pong Example

csharp

Thread pingThread = new Thread(Ping);
Thread pongThread = new Thread(Pong);
pingThread.IsBackground = true;
pongThread.IsBackground = true;
pingThread.Start();
pongThread.Start();
pingThread.Join();
pongThread.Join();

Run in parallel the two loops interleave their output, instead of one finishing before the other starts.

Lifecycle and Background Threads

Unstarted

created, not started

Running

after Start

WaitSleepJoin

blocked on Sleep or Join

Stopped

the method returned

Foreground threads, the default, keep the application alive until they finish
Background threads are terminated once every foreground thread is done
Abort is deprecated, and a thread can never be started twice

What Is a Race Condition

A race condition: Several threads reaching shared data at the same time, where the outcome depends on timing nobody controls.

Two threads read a shared counter as 0
Each increments its own copy to 1
Both write 1 back, and the expected 2 is lost
The code still looks correct, which is why results vary from run to run

The Race in Practice

csharp

static void IncrementCounter(object state)
{
    // WITHOUT LOCK - race condition can occur
    for (int i = 0; i < 100; i++) counter++;
}

Queuing increments and decrements that should cancel to 0 rarely produces 0.

Preventing It with lock

csharp

static object lockObject = new object();

lock (lockObject)
{
    for (int i = 0; i < 100; i++) counter++;
}

The Thread Pool

csharp

ThreadPool.SetMaxThreads(50, 50);
ThreadPool.QueueUserWorkItem(IncrementCounter);

The pool is a set of pre-created threads managed by the runtime
So a task avoids the cost of creating a fresh thread for itself
QueueUserWorkItem hands work to whichever pooled thread is free

Pool Compared With Manual Threads

	ThreadPool	Manual thread
Creation cost	low, threads are reused	high, each one is fresh
Control	limited	full, over lifecycle and priority
Suits	short tasks	long-running operations
Cleanup	automatic	yours to handle

Performance: One Thread Against Four

csharp

long partialSum = 0;
for (int i = start; i <= end; i++) partialSum += i;
lock (lockObject) { totalSum += partialSum; }

One lock per thread, not one per iteration. Locking every iteration is correct and very slow.

Summing one billion numbers on a 4-core CPU took roughly 4000 ms single-threaded
And about 1200 ms across four threads
That is a 3.3x speedup, not a full 4x, because synchronization is not free

Best Practices

Do

Use the pool for short tasks
Keep every lock as brief as possible
Prefer local variables over shared state
Mark non-essential threads as background
Wrap thread code in try-catch

Do not

Call Abort
Lock on public objects, types or strings
Spawn a large number of manual threads
Leave a known race unsynchronized
Forget to dispose resources

Key Takeaways

A program becomes a process when run, and a process holds threads that share its memory
Start begins a thread and Join waits for it, which together are fork-join
Unsynchronized reads and writes to shared data race, and lock protects the critical section
The pool reuses worker threads and beats manual creation for short tasks
Computing a partial result locally and locking once keeps contention low
Multi-threading speeds up CPU-bound work, but always by less than the core count

Open this lesson

Mahmoud AbasOperating System Lab - Week 7

Style

How the work runs

Synchronous

sequentially, each operation finishing before the next begins

Asynchronous

concurrently, a later one starting before an earlier one finishes

Thread pingThread = new Thread(Ping); Thread pongThread = new Thread(Pong); pingThread.IsBackground = true; pongThread.IsBackground = true; pingThread.Start(); pongThread.Start(); pingThread.Join(); pongThread.Join();

ThreadPool

Manual thread

Creation cost

low, threads are reused

high, each one is fresh

Control

limited

full, over lifecycle and priority

Suits

short tasks

long-running operations

Cleanup

automatic

yours to handle