Operating Systems 1 (2026-2027)

Operating Systems 1, Lab 5

C# Threads Basics

One main thread, then many: create, start, pass data, wait, and watch every state

Objectives

Explain process, thread and the main thread
See why one thread runs everything sequentially
Create and start threads with the Thread class
Pass data in with ParameterizedThreadStart, then type-safely; get a result back with a callback
Follow ThreadState through Start, Sleep and Join
Predict foreground and background threads when Main ends

Part 1

Processes and Threads

Who actually runs your code?

A Thread Runs the Code

Multitasking: a browser, Visual Studio and Notepad open at the same time

Operating system

runs many applications

runs each app in a

Process

one per application, own PID

does the work with a

Thread

executes the code

Thread: A unit of a process that executes the application's code (a lightweight process)

Every Process Starts with One Thread

By default a process gets one thread: the main thread
The main thread starts executing your program at Main
So every program is single-threaded until you create more threads yourself
A thread belongs to its process: it cannot run another application's code
All threading classes live in System.Threading

Worked Example: Naming the Main Thread

CurrentThread is static; Name belongs to the thread object. Predict the first two lines.

csharp

Thread t = Thread.CurrentThread;
Console.WriteLine("Name before: [" + t.Name + "]");
Console.WriteLine("Name is null: " + (t.Name == null));
t.Name = "Main Thread";
Console.WriteLine("t.Name: " + t.Name);
Console.WriteLine("Thread.CurrentThread.Name: " + Thread.CurrentThread.Name);

text

Name before: []
Name is null: True
t.Name: Main Thread
Thread.CurrentThread.Name: Main Thread

Part 2

One Thread vs Many

What waiting costs, and how threads avoid it

Worked Example: The Database Wait

Main calls Method1(), Method2(), Method3() and times itself. Predict: when does Method3 start? How long does Main take?

csharp

static void Method2()
{
    for (int i = 1; i <= 3; i++)
    {
        if (i == 2)
        {
            Console.WriteLine("Method2: database operation started");
            Thread.Sleep(5000);   // pretend this is a slow DB call
            Console.WriteLine("Method2: database operation completed");
        }
        Console.WriteLine("Method2: " + i);
    }
}

The Database Wait: Output

text

Main started
Method1: 1
Method1: 2
Method1: 3
Method2: 1
Method2: database operation started
Method2: database operation completed
Method2: 2
Method2: 3
Method3: 1
Method3: 2
Method3: 3
Main ended after 5.0 s

One thread means sequential execution: a method starts only after the previous one ends
Method3 waited 5 s for a database call it does not need
While the thread sleeps, the CPU does nothing for us
With a window, a wait like this freezes the UI

Worked Example: Three Threads

Fix: give each method its own thread. Predict: same order every run? When does Main end?

csharp

Stopwatch sw = Stopwatch.StartNew();
Thread.CurrentThread.Name = "Main";
Console.WriteLine("Main started");
Thread t1 = new Thread(Method1) { Name = "Thread1" };
Thread t2 = new Thread(Method2) { Name = "Thread2" };
Thread t3 = new Thread(Method3) { Name = "Thread3" };
t1.Start();
t2.Start();
t3.Start();
Console.WriteLine("Main ended after " + sw.Elapsed.TotalSeconds.ToString("0.0") + " s");

Three Runs, Three Orders

The order in which the loops printed their numbers, from three real runs

Run	Order of the loop lines	Main ended after
1	Method1 1-3, Method2 1, Method3 1-3, Method2 2-3	0.1 s
2	Method1 1, Method2 1, Method1 2-3, Method3 1-3, Method2 2-3	0.0 s
3	Method3 1-3, Method1 1-3, Method2 1, Method2 2-3	0.1 s

Taking Turns on the CPU

Each thread gets a short time slice; an unfinished thread waits for its next turn

t1
slice
t2
slice
t3
slice
t1
again
t2
again

On one core only one thread runs at any instant; switching is so fast they look simultaneous
Our lab machines have several cores, so two threads can also run at the very same moment
Either way we do not choose who runs when: the output order is unpredictable

Main Thread and Worker Threads

Main thread

created by the process, starts at Main

t1

worker

t2

worker

t3

worker

Threads created by the main thread are its worker (child) threads
Execution always starts on the main thread
Use threads for independent methods: if one needs another's result, it must wait for it
Creating a thread costs time too: strictly sequential work gains nothing

Part 3

The Thread Class

Entry points, data in, results out

Worked Example: Inherit from Thread?

Predict: does this compile?

csharp

class MyThread : Thread
{
}

text

Program.cs(4,18): error CS0509: 'MyThread': cannot derive from sealed type 'Thread'

What a Thread Object Tells You

Member	Meaning
`Thread.CurrentThread`	static: the thread executing this line
`Name`	get or set the name (`null` by default)
`ThreadState`	the current state of the thread
`IsAlive`	`True` from `Start` until the thread ends
`IsBackground`	get or set: background or foreground thread

The Constructor Takes a Delegate

A thread needs an entry point: a pointer to the method it starts in

Delegate	Matches	Start with
`ThreadStart`	`void M()`	`t.Start()`
`ParameterizedThreadStart`	`void M(object x)`	`t.Start(value)`

Both return void: a thread method cannot return a value directly
One parameter at most, and its type is object
Only these two: your own delegate type is not accepted

Five Ways to Create the Same Thread

DisplayNumbers() prints its thread's name and 1 2 3. Predict the output.

csharp

Thread t1 = new Thread(DisplayNumbers) { Name = "t1" };
ThreadStart ts = new ThreadStart(DisplayNumbers);
Thread t2 = new Thread(ts) { Name = "t2" };
Thread t3 = new Thread(new ThreadStart(DisplayNumbers)) { Name = "t3" };
Thread t4 = new Thread(delegate () { DisplayNumbers(); }) { Name = "t4" };
Thread t5 = new Thread(() => DisplayNumbers()) { Name = "t5" };

text

Run 1          Run 2          Run 3
t1: 1 2 3      t1: 1 2 3      t2: 1 2 3
t4: 1 2 3      t2: 1 2 3      t4: 1 2 3
t2: 1 2 3      t3: 1 2 3      t3: 1 2 3
t5: 1 2 3      t5: 1 2 3      t1: 1 2 3
t3: 1 2 3      t4: 1 2 3      t5: 1 2 3

Worked Example: A Method That Returns int

Predict: does new Thread(Sum) compile?

csharp

Thread t1 = new Thread(Sum);
t1.Start();

static int Sum()
{
    int result = 0;
    for (int i = 1; i <= 5; i++)
        result += i;
    return result;
}

Try It: Does the Method Fit?

Passing Data: ParameterizedThreadStart

The method takes one object; the value goes into Start

csharp

Program obj = new Program();
Thread t1 = new Thread(obj.DisplayNumbers);
t1.Start(5);

public void DisplayNumbers(object max)
{
    int number = Convert.ToInt32(max);
    for (int i = 1; i <= number; i++)
        Console.WriteLine("Number: " + i);
}

text

Number: 1
Number: 2
Number: 3
Number: 4
Number: 5

Start(5) passes 5 to the delegate, which passes it to max
Convert.ToInt32 turns the object back into an int

Worked Example: Start("hi")

Change one line to t1.Start("hi"); Predict: compile error, or something else?

Not type-safe: an object parameter accepts any value
A wrong value is found only at run time, never by the compiler
Every value is boxed on the way in and unboxed or converted on the way out

Type-Safe Data: A Helper Class

csharp

class NumberHelper
{
    private int _number;

    public NumberHelper(int number)
    {
        _number = number;
    }

    public void DisplayNumbers()
    {
        for (int i = 1; i <= _number; i++)
            Console.WriteLine("Number: " + i);
    }
}

Data enters through the constructor, with its real type
It is kept in a private field
The thread method takes no parameter: it fits ThreadStart
Use: new Thread(obj.DisplayNumbers) after obj = new NumberHelper(5)

Worked Example: new NumberHelper("hi")

Same mistake as before, now with the helper class. Predict: when is it caught?

csharp

NumberHelper obj = new NumberHelper("hi");
Thread t1 = new Thread(obj.DisplayNumbers);
t1.Start();

text

Program.cs(24,45): error CS1503: Argument 1: cannot convert from 'string' to 'int'

Getting a Result Back: a Callback

csharp

public delegate void ResultCallback(int result);

public void CalculateSum()
{
    int result = 0;
    for (int i = 1; i <= _number; i++)
    {
        Console.WriteLine(i);
        result = result + i;
    }
    if (_callback != null)
        _callback(result);
}

Declare a delegate type for the method that gets the result
Keep one in a private field, filled by the constructor
At the end of the thread method, invoke it with the result
The caller decides which method receives it

Worked Example: Sum of 1 to 10

Predict the last line (the output ends with its last 3 of 11 lines). S = the sum.

csharp

ResultCallback callback = new ResultCallback(ShowResult);
NumberHelper obj = new NumberHelper(10, callback);
Thread t1 = new Thread(obj.CalculateSum);
t1.Start();
static void ShowResult(int result)
{
    Console.WriteLine("Sum of the numbers is: " + result);
}

text

9
10
Sum of the numbers is: 55

S = 1 + 2 + 3 + ⋯ + 10 = 55

Part 4

The Life of a Thread

States, Sleep, Join, foreground and background

Four States

Life-cycle state	`ThreadState`	When
Unstarted	`Unstarted`	created, `Start` not called yet
Ready / running	`Running`	started and not blocked
Not runnable	`WaitSleepJoin`	blocked in `Sleep`, `Join`, or waiting
Dead	`Stopped`	its method has finished

Unstarted

Start()

Running

Sleep / Join

WaitSleepJoin

wakes up

Running

again

method ends

Stopped

Worked Example: Watching ThreadState

Predict lines 1 to 5 before revealing

csharp

Thread t = new Thread(Work);
Console.WriteLine("1) after new:       " + t.ThreadState + ", IsAlive = " + t.IsAlive);
t.Start();
Thread.Sleep(500);   // give the worker time to reach its Sleep
Console.WriteLine("3) while it sleeps: " + t.ThreadState + ", IsAlive = " + t.IsAlive);
t.Join();
Console.WriteLine("5) after Join:      " + t.ThreadState + ", IsAlive = " + t.IsAlive);

static void Work()
{
    Console.WriteLine("2) inside Work:     " + Thread.CurrentThread.ThreadState);
    Thread.Sleep(2000);
    Console.WriteLine("4) Work is about to end");
}

Watching ThreadState: Answer

text

1) after new:       Unstarted, IsAlive = False
2) inside Work:     Running
3) while it sleeps: WaitSleepJoin, IsAlive = True
4) Work is about to end
5) after Join:      Stopped, IsAlive = False

Line 2: a thread asking about itself is always Running
Line 3: Main slept 0.5 s, so the worker is inside its 2 s Sleep
Line 5: Join returned only after Work ended

Worked Example: Sleep

ProcessSleep loops i = 0 to 5 and calls Thread.Sleep(4000) each pass; Main starts it, joins it, and prints the time. Predict TotalTime.

csharp

static void ProcessSleep()
{
    for (int i = 0; i <= 5; i++)
    {
        Console.WriteLine("work is in progress..!");
        Thread.Sleep(4000); // sleep for 4 seconds
    }
}

T = n × s = 6 × 4 = 24

text

TotalTime 00:00:24
work completed..!

Worked Example: Join

t.Join() makes the calling thread wait until t ends. Predict the output without the Join line.

csharp

Thread oThread = new Thread(MethodJoin);   // prints "work is in progress..!" 3 times
oThread.Start();
oThread.Join();
Console.WriteLine("work completed..!");

With Join	Without Join (6 of 6 runs)
`work is in progress..!`	`work completed..!`
`work is in progress..!`	`work is in progress..!`
`work is in progress..!`	`work is in progress..!`
`work completed..!`	`work is in progress..!`

Foreground and Background Threads

	Foreground (default)	Background
`IsBackground`	`False`	`True`
Main thread ends first	keeps running to the end	stopped with the last foreground thread
Keeps the program alive	yes	no

Worked Example: A Foreground Worker

Predict the output, and how long the program runs

csharp

Thread oThread = new Thread(WorkThread);
oThread.Start();
Console.WriteLine("Main Thread Quits..!");

static void WorkThread()
{
    for (int i = 0; i <= 4; i++)
    {
        Console.WriteLine("Worker Thread is in progress..!");
        Thread.Sleep(2000); // sleep for 2 seconds
    }
    Console.WriteLine("Worker Thread Quits..!");
}

A Foreground Worker: Output

text

Worker Thread is in progress..!
Main Thread Quits..!
Worker Thread is in progress..!
Worker Thread is in progress..!
Worker Thread is in progress..!
Worker Thread is in progress..!
Worker Thread Quits..!

Main quit at once
The worker still finished all 5 passes
The program ran 10.08 s: 5 sleeps of 2 s
Same reason the three-thread program lasted 5 s

Worked Example: Make It Background

Add one line before Start. Predict the output.

csharp

Thread oThread = new Thread(WorkThread);
oThread.IsBackground = true;
oThread.Start();
Console.WriteLine("Main Thread Quits..!");

text

Main Thread Quits..!
Worker Thread is in progress..!

Try It: The Thread Timeline

Looking ahead

A First Look at Task

System.Threading.Tasks.Task runs an action on a separate thread for you. Predict: which line comes right after Main thread started?

csharp

Console.WriteLine("Main thread started");
Task task = new Task(() =>
{
    Console.WriteLine("Running task in separate thread");
    int result = AddNumbers(5, 10);
    Console.WriteLine("Result of addition: " + result);
});
task.Start();
Console.WriteLine("Main thread is done");
Console.ReadLine();

text

Main thread started
Main thread is done
Running task in separate thread
Result of addition: 15

Part 5

Practice

About 30 minutes: predict on paper, then run it and check

About 5 minutes: predict every line, in order

Practice 1: States

csharp

Thread t = new Thread(Work) { Name = "Worker" };
Console.WriteLine("A: " + t.ThreadState);
Console.WriteLine("B: " + t.IsBackground);
t.Start();
Thread.Sleep(1000);
Console.WriteLine("C: " + t.ThreadState + " " + t.IsAlive);
t.Join();
Console.WriteLine("D: " + t.ThreadState + " " + t.IsAlive);
static void Work()
{
    Thread me = Thread.CurrentThread;
    Console.WriteLine("W: " + me.Name + " " + me.ThreadState);
    Thread.Sleep(3000);
}

Practice 1: Answer

text

A: Unstarted
B: False
W: Worker Running
C: WaitSleepJoin True
D: Stopped False

B: a new thread is a foreground thread
W: a thread asking about itself is always Running
C: after 1 s the worker is still inside its 3 s Sleep

About 6 minutes

Practice 2: How Long?

Predict both times. And without the three Join calls?

csharp

Stopwatch sw = Stopwatch.StartNew();
Download(); Resize(); Save();
Console.WriteLine("One thread:    " + sw.Elapsed.TotalSeconds.ToString("0.0") + " s");
sw.Restart();
Thread t1 = new Thread(Download);
Thread t2 = new Thread(Resize);
Thread t3 = new Thread(Save);
t1.Start(); t2.Start(); t3.Start();
t1.Join(); t2.Join(); t3.Join();
Console.WriteLine("Three threads: " + sw.Elapsed.TotalSeconds.ToString("0.0") + " s");
static void Download() { Thread.Sleep(2000); }
static void Resize()   { Thread.Sleep(3000); }
static void Save()     { Thread.Sleep(1000); }

Practice 2: Answer

text

One thread:    6.0 s
Three threads: 3.0 s

T₁ = 2 + 3 + 1 = 6

T₃ = 3

About 8 minutes

Practice 3: A Factorial on a Thread

Write FactorialHelper: it computes n! (1 x 2 x ... x n) on a separate thread
Pass n in a type-safe way
Return the result with a callback that prints lines like 5! = 120
In Main, compute 5! then 10!, each on its own thread; 5! must print first
What happens with new FactorialHelper("5", ShowResult)?

Practice 3: Answer

With public delegate void FactorialCallback(int n, long result);

csharp

public FactorialHelper(int n, FactorialCallback callback)
{ _n = n; _callback = callback; }

public void Calculate()
{
    long result = 1;
    for (int i = 2; i <= _n; i++)
        result = result * i;
    if (_callback != null)
        _callback(_n, result);
}

text

5! = 120
10! = 3628800

t.Join() after the first thread keeps 5! first
"5": error CS1503, cannot convert from 'string' to 'int'

About 5 minutes

Practice 4: Foreground or Background?

Predict the output as written, then with worker.IsBackground = true; before Start

csharp

Thread worker = new Thread(Tick);
worker.Start();
Thread.Sleep(1500);
Console.WriteLine("Main done");
static void Tick()
{
    for (int i = 1; i <= 3; i++)
    {
        Console.WriteLine("tick " + i);
        Thread.Sleep(1000);
    }
    Console.WriteLine("Worker done");
}

Practice 4: Answer

Each version: the same output in 10 of 10 runs

Foreground (as written)	Background
`tick 1`	`tick 1`
`tick 2`	`tick 2`
`Main done`	`Main done`
`tick 3`	(nothing more)
`Worker done`

About 6 minutes

Practice 5: ParameterizedThreadStart

csharp

Thread t = new Thread(PrintSquares);
t.Start(4);
t.Join();
Console.WriteLine("Main done");
static void PrintSquares(object max)
{
    int n = Convert.ToInt32(max);
    for (int i = 1; i <= n; i++)
        Console.WriteLine(i + " x " + i + " = " + (i * i));
}

Predict the output. Then: does the compiler catch t.Start("four")?
Which fit: void A(), void B(object x), void C(int x), int D()?

Practice 5: Answer

text

1 x 1 = 1
2 x 2 = 4
3 x 3 = 9
4 x 4 = 16
Main done

Method	new Thread(M)
`void A()`	`ThreadStart`
`void B(object x)`	`ParameterizedThreadStart`
`void C(int x)`	error `CS1503`
`int D()`	error `CS1503`

Key Takeaways

A process runs your app; its main thread runs the code, one line at a time
new Thread(method) + Start(): the methods run side by side, in an unpredictable order
Entry points are ThreadStart or ParameterizedThreadStart: void, no parameter or one object
Pass data type-safely with a helper class; return results with a callback
Sleep and Join put a thread in WaitSleepJoin; a finished thread is Stopped
Background threads die with the last foreground thread

Open this lesson

Mahmoud AbasC# Threads Basics