Mahmoud Abas, Full-Stack Software Engineer & AI

Operating Systems 1, Lab 6

C# Thread Synchronization

When threads share data: lost updates, lock, Monitor, and the UI thread

Objectives

Explain data inconsistency and the race condition behind it, with real runs
Find the critical section of a program and protect it with lock
Describe what lock compiles to: Monitor.Enter, Monitor.Exit, try/finally
Use Monitor: TryEnter with a timeout, and Wait/Pulse to make threads take turns
Tell exclusive from non-exclusive locks, and limit threads with a Semaphore
Update a Windows Forms control from a worker thread with Invoke or a BackgroundWorker

Part 1

When Threads Share Data

Same code, different answers

Shared Resources

Data inconsistency: wrong or mixed results when more than one thread uses a shared resource at the same time

A shared resource: in-memory data (a class or instance variable), a method, or an external object such as a file
One thread reads it while another writes it: the result depends on who runs when
The operating system decides who runs when, not your code, so the result can change from run to run

Worked Example: Three Threads, One Method

Three threads start SomeMethod; Main joins them and prints the time. Predict the output.

csharp

static void SomeMethod()
{
    Console.Write("[Welcome To The ");
    Thread.Sleep(1000);
    Console.WriteLine("World of Dotnet!]");
}

Three Threads, One Method: Answer

text

[Welcome To The [Welcome To The [Welcome To The World of Dotnet!]
World of Dotnet!]
World of Dotnet!]
Total: 1.1 s

Worked Example: 10 Tickets, Two Bookings

T1 books 3, T2 books 2. Each thread reads the count, works for 100 ms, then writes the new count. Predict Tickets left.

csharp

static int availableTickets = 10;

static void Book(int wanted)
{
    string name = Thread.CurrentThread.Name;
    int seen = availableTickets;           // 1) read
    Console.WriteLine(name + " read " + seen);
    Thread.Sleep(100);                     // a slow step
    availableTickets = seen - wanted;      // 2) compute, 3) write
    Console.WriteLine(name + " wrote " + availableTickets);
}

text

T1 read 10
T2 read 10
T1 wrote 7
T2 wrote 8
Tickets left: 8

10 - 3 - 2 = 5

`count++` Is Three Steps

The IL the compiler produced for count++ in our counter program (read with a disassembler)

csharp

count++;

text

ldsfld  int32 Program::count   // 1) read count
ldc.i4.1
add                            // 2) add 1
stsfld  int32 Program::count   // 3) write count

A thread can be switched out between any two of these steps
Two threads that both read 5 both write 6: one increment is lost
The same read, compute, write gap as the ticket example, only much shorter

Worked Example: Three Threads, One Counter

Each thread runs count++ 1,000,000 times. Called one after another, the program prints count = 3000000. Predict the threaded result.

csharp

static int count = 0;

static void IncrementCount()
{
    for (int i = 1; i <= 1000000; i++)
    {
        count++;
    }
}
// Main: start t1, t2, t3 on IncrementCount,
// Join all three, print count

Run	count
1	`2433729`
2	`1646435`
3	`1076791`
4	`1508029`
5	`1179164`

Try It: Race Two Threads

Worked Example: Booking the Last 3 Tickets

Thread1 wants 1, Thread2 wants 2, Thread3 wants 3, all on one BookMyShow object. Predict: how many tickets get booked?

csharp

public int AvailableTickets = 3;

public void BookTicket(string name, int wantedTickets)
{
    if (wantedTickets <= AvailableTickets)
    {
        Console.WriteLine(wantedTickets + " booked to " + name);
        AvailableTickets = AvailableTickets - wantedTickets;
    }
    else
    {
        Console.WriteLine("No tickets available to book for " + name);
    }
}

text

2 booked to Thread2
1 booked to Thread1
3 booked to Thread3
Tickets left: -3

The Critical Section

Critical section: the part of the code that uses a shared resource and must never run on two threads at once

Tickets: the if that checks AvailableTickets and the line that updates it
Counter: count++, all three of its steps
Thread synchronization lets only one thread at a time into the critical section; the others wait at its door

Why Synchronize?

Goal	Meaning	Example
Atomicity	the critical section runs as one unit, by one thread at a time	ticket booking, the counter
Ordering	threads work in a chosen order, or only a limited number may enter	one whole message at a time; even and odd numbers in turn

Part 2

The lock Statement

One thread in the critical section at a time

lock: Syntax

csharp

private static readonly object lockObject = new object();

static void SomeMethod()
{
    lock (lockObject)
    {
        // critical section:
        // one thread at a time
    }
}

A thread that reaches lock acquires the lock and enters
Any other thread waits at lock until the owner leaves the block
Lock on a dedicated object that is used for nothing else
private: outside code cannot lock it; readonly: it can never be replaced
static method: static lock object; an instance method may use an instance field

Worked Example: Welcome, with a Lock

Same three threads; the body of SomeMethod is now inside lock, with a message before, inside and after. Predict the order and the time.

csharp

Console.WriteLine(name + " trying to acquire the lock");
lock (lockObject)
{
    Console.WriteLine(name + " got the lock");
    Console.Write("[Welcome To The ");
    Thread.Sleep(1000);
    Console.WriteLine("World of Dotnet!]");
    Console.WriteLine(name + " releases the lock");
}

text

Thread 2 trying to acquire the lock
Thread 3 trying to acquire the lock
Thread 3 got the lock
[Welcome To The Thread 1 trying to acquire the lock
World of Dotnet!]
Thread 3 releases the lock
Thread 2 got the lock
[Welcome To The World of Dotnet!]
Thread 2 releases the lock
Thread 1 got the lock
[Welcome To The World of Dotnet!]
Thread 1 releases the lock
Total: 3.0 s

Welcome, with a Lock: Reading the Output

Worked Example: Fixing the Counter

Put only count++ inside the lock. Predict count.

csharp

private static readonly object lockCount = new object();

static void IncrementCount()
{
    for (int i = 1; i <= 1000000; i++)
    {
        lock (lockCount)
        {
            count++;
        }
    }
}

text

count = 3000000

30 of 30 runs: 3000000
i is a local variable: each thread has its own, so the loop stays outside the lock
The lock is taken and released 3 x 1000000 times: correct, but slower than no lock

Worked Example: Booking with a Lock

Wrap the check and the update in one lock. Predict the possible outputs.

csharp

lock (lockObject)
{
    if (wantedTickets <= AvailableTickets)
    {
        Console.WriteLine(wantedTickets + " booked to " + name);
        AvailableTickets = AvailableTickets - wantedTickets;
    }
    else
    {
        Console.WriteLine("No tickets available to book for " + name);
    }
}

Runs	Output, 60 runs
51	1 to Thread1, 2 to Thread2, none for Thread3
7	1 to Thread1, none for Thread3, 2 to Thread2
1	2 to Thread2, 1 to Thread1, none for Thread3
1	2 to Thread2, none for Thread3, 1 to Thread1

What lock Compiles To

The compiler turns lock (lockObject) { body } into this

csharp

object temp = lockObject;
bool lockTaken = false;
try
{
    Monitor.Enter(temp, ref lockTaken);
    // body
}
finally
{
    if (lockTaken)
    {
        Monitor.Exit(temp);
    }
}

Monitor.Enter gives the lock to one thread and sets that thread's lockTaken to true
ref: Enter writes into the caller's own variable
finally always runs, even after an exception, so the lock is always released
We ran this form, written by hand, for the counter: count = 3000000 in 10 of 10 runs

The IL Agrees

The IL of IncrementCount in the compiled lock version, trimmed. bool& means ref bool.

text

.try
{
    call void System.Threading.Monitor::Enter(object, bool&)
    ldsfld int32 Program::count
    ldc.i4.1
    add
    stsfld int32 Program::count
    leave.s IL_0032
}

The IL Agrees: the finally Block

text

finally
{
    ldloc.2              // lockTaken
    brfalse.s IL_0031    // false: skip Exit
    call void System.Threading.Monitor::Exit(object)
}

Worked Example: An Exception Inside the Lock

Thread A throws inside the lock and catches it outside. Then B takes the same lock; Main gives it 2 s: b.Join(TimeSpan.FromSeconds(2)) returns true if B finished. Predict the last line.

csharp

static void Faulty()          // thread A
{
    try
    {
        lock (lockObject)
        {
            Console.WriteLine("A has the lock");
            int tickets = int.Parse("three");        // throws FormatException
        }
    }

An Exception Inside the Lock: the catch Block

csharp

    catch (FormatException ex)
    {
        Console.WriteLine("A caught: " + ex.Message);
    }
}

text

A has the lock
A caught: The input string 'three' was not in a correct format.
B has the lock
B finished within 2 s: True

Worked Example: Monitor Without finally

Same program, but thread A uses Monitor.Enter and Monitor.Exit with no finally. Predict the last line.

csharp

try
{
    Monitor.Enter(lockObject);
    Console.WriteLine("A has the lock");
    int tickets = int.Parse("three");        // throws FormatException
    Monitor.Exit(lockObject);                  // skipped by the exception
}
catch (FormatException ex)
{
    Console.WriteLine("A caught: " + ex.Message);
}

Monitor Without finally: Answer

text

A has the lock
A caught: The input string 'three' was not in a correct format.
B finished within 2 s: False

Part 3

The Monitor Class

Everything lock does, plus timeouts and signals

Monitor: The Methods

Method	What it does
`Enter(obj)`, `Enter(obj, ref taken)`	take the lock; wait in the ready queue while another thread holds it
`Exit(obj)`	release the lock; a thread from the ready queue can take it
`TryEnter(obj, timeout, ref taken)`	like `Enter`, but give up after the timeout (`taken` stays `false`)
`Wait(obj)`	release the lock and sleep in the waiting queue until a `Pulse`
`Pulse(obj)`	move one thread from the waiting queue to the ready queue

Worked Example: Monitor.Enter and Monitor.Exit

Three threads run PrintNumbers. Predict: can two threads print their numbers at the same time?

csharp

Console.WriteLine(name + " trying to enter the critical section");
try
{
    Monitor.Enter(lockPrintNumbers);
    Console.WriteLine(name + " entered the critical section");
    for (int i = 0; i < 5; i++)
    {
        Thread.Sleep(100);
        Console.Write(i + ",");
    }
    Console.WriteLine();
}

Monitor.Enter and Monitor.Exit: the finally Block

csharp

finally
{
    Monitor.Exit(lockPrintNumbers);
    Console.WriteLine(name + " exit from the critical section");
}

Monitor.Enter and Monitor.Exit: Answer

text

Child Thread 2 trying to enter the critical section
Child Thread 1 trying to enter the critical section
Child Thread 2 entered the critical section
Child Thread 3 trying to enter the critical section
0,1,2,3,4,
Child Thread 2 exit from the critical section
Child Thread 1 entered the critical section
0,1,2,3,4,
Child Thread 1 exit from the critical section
Child Thread 3 entered the critical section
0,1,2,3,4,
Child Thread 3 exit from the critical section

Worked Example: TryEnter with a Timeout

Each thread holds the lock for 5 x 100 ms and waits at most 1 s for it. Predict: do all three threads print?

csharp

TimeSpan timeout = TimeSpan.FromSeconds(1);
bool lockTaken = false;
try
{
    Monitor.TryEnter(lockPrintNumbers, timeout, ref lockTaken);
    if (lockTaken)
    {
        // "entered", the 5 numbers, a new line: as before
    }
    else
        Console.WriteLine(name + ": lock was not acquired");
}

TryEnter with a Timeout: the finally Block

csharp

finally
{
    if (lockTaken)
    {
        Monitor.Exit(lockPrintNumbers);   // then prints "exit"
    }
}

TryEnter: Answer

text

Child Thread 2 trying to enter the critical section
Child Thread 3 trying to enter the critical section
Child Thread 3 entered the critical section
Child Thread 1 trying to enter the critical section
0,1,2,3,4,
Child Thread 3 exit from the critical section
Child Thread 2 entered the critical section
0,1,2,3,Child Thread 1: lock was not acquired
4,
Child Thread 2 exit from the critical section

W = 2 × 5 × 100 = 1000

Taking Turns: Wait and Pulse

Goal: 0 1 2 3 ... 20, the even numbers from one thread and the odd numbers from another

evenThread prints 0, then calls Pulse: a waiting thread may get ready
evenThread calls Wait: it releases the lock and sleeps in the waiting queue
oddThread takes the lock, prints 1, calls Pulse (evenThread gets ready), then Wait
evenThread takes the lock back, returns from Wait and prints 2, and so on
Each thread's last number skips Wait: nobody would be left to pulse it

Worked Example: Even and Odd

numberLimit = 20. Predict the output.

csharp

static void PrintEvenNumbers()
{
    try
    {
        Monitor.Enter(lockMonitor);

Even and Odd: the Loop

csharp

        for (int i = 0; i <= numberLimit; i = i + 2)
        {
            Console.Write(i + " ");
            Monitor.Pulse(lockMonitor);
            bool isLast = (i == numberLimit);
            if (!isLast)
                Monitor.Wait(lockMonitor);
        }
    }
    finally { Monitor.Exit(lockMonitor); }
}

PrintOddNumbers: the same with i = 1 and isLast = (i == numberLimit - 1)
Both threads use the same lock object, lockMonitor
Main: start evenThread, Thread.Sleep(100) so it runs first, start oddThread, Join both

Even and Odd: Answer

text

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Main method completed

Try It: Inside the Monitor

Worked Example: Remove the isLast Check

Both threads always call Wait. They are background threads, and Main waits at most 2 s for each: Join(TimeSpan) returns true if the thread finished. Predict the last line.

csharp

Console.Write(i + " ");
Monitor.Pulse(lockMonitor);
Monitor.Wait(lockMonitor);          // no isLast check

// in Main
bool oddDone = oddThread.Join(TimeSpan.FromSeconds(2));
bool evenDone = evenThread.Join(TimeSpan.FromSeconds(2));
Console.WriteLine("odd finished: " + oddDone + ", even finished: " + evenDone);

Remove the isLast Check: Answer

text

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
odd finished: True, even finished: False

lock or Monitor?

	`lock`	`Monitor`
Take and release	automatic, at `{` and `}`	`Enter` and `Exit`, by hand
After an exception	always released	only with your own `try`/`finally`
Give up after a timeout	no	`TryEnter`
Signal another thread	no	`Wait`, `Pulse`, `PulseAll`

Exclusive and Non-Exclusive Locks

Lock type	Who may enter	C# tools
Exclusive	one thread at a time	`lock`, `Monitor`, `Mutex`, `SpinLock`
Non-exclusive	a limited number of threads	`Semaphore`, `SemaphoreSlim`, `ReaderWriterLockSlim`

Worked Example: A Semaphore with 2 Slots

Five threads each hold a slot for 1 s. Predict the total time.

csharp

static Semaphore sm = new Semaphore(2, 2);   // 2 free slots, at most 2

static void Work()
{
    string name = Thread.CurrentThread.Name;
    sm.WaitOne();                     // take a slot, or wait for one
    Console.WriteLine(Now() + " " + name + " entered");
    Thread.Sleep(1000);
    Console.WriteLine(Now() + " " + name + " is leaving");
    sm.Release();                     // give the slot back
}

text

0.0 s Thread 2 entered
0.0 s Thread 1 entered
1.0 s Thread 2 is leaving
1.0 s Thread 3 entered
1.0 s Thread 1 is leaving
1.0 s Thread 4 entered
2.0 s Thread 3 is leaving
2.0 s Thread 5 entered
2.0 s Thread 4 is leaving
3.0 s Thread 5 is leaving
All done at 3.0 s

A Semaphore with 2 Slots: the Total Time

T = r × s = 3 × 1 = 3

Part 4

Threads and the User Interface

A Windows Forms app has one UI thread

The Message Pump

Application.Run(new Form1()) runs this loop on the UI thread

Windows

mouse, keys, paint

Message queue

first in, first out

Message pump

one message at a time

dispatch

Your handler

button1_Click

Every mouse move, key press and paint request waits in the queue
While a handler runs, no other message is handled, not even a repaint
Every control belongs to the UI thread that created it

Worked Example: Work on the UI Thread

The click handler sets the text, then works for 20 s. Predict what the window shows after 8 s.

csharp

private void button1_Click(object sender, EventArgs e)
{
    textBox1.Text = "Working";
    Thread.Sleep(20 * 1000);   // 20 s of work on the UI thread
    textBox1.Text = "Done";
}

Work on the UI Thread: Answer

The window 8 seconds after the click: the text box is still empty

The window after 20 seconds: the text box shows Done

Worked Example: Counting on a Worker Thread

The click starts a background thread that writes 0 to 9 into textBox1, one per second. Predict what happens under the debugger (F5).

csharp

private void button1_Click(object sender, EventArgs e)
{
    var thread = new Thread(StartCounting);
    thread.IsBackground = true;
    thread.Start();
}

Counting on a Worker Thread: StartCounting

csharp

private void StartCounting()
{
    for (var i = 0; i < 10; i++)
    {
        textBox1.Text = i.ToString();
        Thread.Sleep(1000);
    }
}

The Check Only Runs Under the Debugger

The same program started without a debugger: the text box shows 3 and the label says CheckForIllegalCrossThreadCalls = False

F5 (debugging) turns the check on: you get the exception
Without a debugger Control.CheckForIllegalCrossThreadCalls is False: the same code showed 3 after 3.5 s
The bug is still there, only hidden: never touch a control from a worker thread
Our exception run set Control.CheckForIllegalCrossThreadCalls = true; in Main to behave like F5

The Fix: Control.Invoke

Invoke hands a delegate to the UI thread, which runs it through the message pump

csharp

private delegate void DisplayCountDelegate(int i);

private void StartCounting()      // worker thread
{
    for (var i = 0; i < 10; i++)
    {
        textBox1.Invoke(new DisplayCountDelegate(DisplayCount), i);
        Thread.Sleep(1000);
    }
    button1.Invoke(new EnableButtonDelegate(EnableButton));
}

The Fix: DisplayCount on the UI Thread

csharp

private void DisplayCount(int i)  // runs on the UI thread
{
    textBox1.Text = i.ToString();
}

The Invoke version after 3.5 seconds: the text box shows 3 and the Start button is disabled

No exception, even with the check on
The click disables button1, so only one counting thread runs; EnableButton turns it back on through Invoke too
At 3.5 s: 3, and the window stays responsive

The Easy Way: BackgroundWorker

Its events run on the thread that created it: the UI thread

csharp

worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.DoWork += StartCounting;                          // worker thread
worker.ProgressChanged += worker_ProgressChanged;        // UI thread
worker.RunWorkerCompleted += worker_RunWorkerCompleted;  // UI thread

// StartCounting calls worker.ReportProgress(i) once a second
private void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    textBox1.Text = e.ProgressPercentage.ToString();
}

The BackgroundWorker version after it finished: the text box shows 9, the button is enabled and the label says Completed

No delegates and no Invoke
RunWorkerAsync() starts DoWork on a worker thread
RunWorkerCompleted re-enabled the button and wrote Completed

Part 5

Practice

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

About 6 minutes

Practice 1: Two Withdrawals

csharp

static int balance = 500;

Thread ATM withdraws 300, thread App withdraws 400; Main joins both and prints Balance
Mark the critical section
Predict the output and the final balance
Fix it with lock. Which outputs are then possible?

Practice 1: the Withdraw Method

csharp

static void Withdraw(int amount)
{
    string name = Thread.CurrentThread.Name;
    if (amount <= balance)
    {
        Console.WriteLine(name + " withdraws " + amount);
        Thread.Sleep(100);                // the bank's slow check
        balance = balance - amount;
    }
    else
    {
        Console.WriteLine(name + ": not enough money");
    }
}

Practice 1: Answer

Version	Output, 20 runs each
No lock	both withdraw, `Balance: -200` (20 of 20)
`lock` around the `if`	`ATM withdraws 300`, `App: not enough money`, `Balance: 200` (19 of 20)
`lock` around the `if`	`App withdraws 400`, `ATM: not enough money`, `Balance: 100` (1 of 20)

About 6 minutes

Practice 2: Where Is the Lock?

Two threads each run Increment; Main joins both and prints count. Predict count for A, B and C.

csharp

// A
lock (lockCount) { for (int i = 0; i < 500000; i++) count++; }

// B
for (int i = 0; i < 500000; i++) { lock (lockCount) { count++; } }

// C
for (int i = 0; i < 500000; i++)
{
    int next = count + 1;
    lock (lockCount) { count = next; }
}

Practice 2: Questions

Which versions always print 1000000?
In which one does one thread do all its increments before the other starts?
In which one can the increments of the two threads interleave?

Practice 2: Answer

Version	`count`, 12 runs each	Why
A	`1000000` in 12	the whole loop is one critical section: one thread runs it all, then the other
B	`1000000` in 12	every `count++` is protected; the lock is released after each one, so the threads interleave
C	12 different values, `491699` to `874943`	the read (`count + 1`) is outside the lock

About 6 minutes

Practice 3: The Shared Printer

Four threads; each holds the lock for 3 pages of 200 ms and waits at most 1 s for it. Predict how many threads print.

csharp

Monitor.TryEnter(lockPrinter, TimeSpan.FromSeconds(1), ref lockTaken);
if (lockTaken)
{
    for (int page = 1; page <= 3; page++)
    {
        Thread.Sleep(200);            // one page takes 200 ms
    }
    Console.WriteLine(name + " printed 3 pages");
}
else
{
    Console.WriteLine(name + " gave up");
}

Practice 3: Answer

text

T1 printed 3 pages
T4 gave up
T2 gave up
T3 printed 3 pages

h = 3 × 200 = 600

About 8 minutes

Practice 4: Ping Pong

Write Play(string word): it prints word and a space, 5 times
Start two threads: Play("ping"), then 100 ms later Play("pong")
Required output: ping pong ping pong ping pong ping pong ping pong, then Game over
Use Monitor.Enter, Pulse, Wait and Exit, as in the even and odd example
Which call must the last round skip, and why?

Practice 4: Answer

csharp

static void Play(string word)
{
    try
    {
        Monitor.Enter(lockBall);
        for (int i = 1; i <= rounds; i++)   // rounds = 5
        {
            Console.Write(word + " ");
            Monitor.Pulse(lockBall);       // wake the other player
            if (i != rounds)
                Monitor.Wait(lockBall);    // hand the ball over and wait
        }
    }

text

ping pong ping pong ping pong ping pong ping pong
Game over

Practice 4: Answer, the finally Block

csharp

    finally
    {
        Monitor.Exit(lockBall);
    }
}

About 4 minutes

Practice 5: Three Slots

The semaphore example with new Semaphore(3, 3), six threads, and 2 s of work each. Predict the total time and the most threads inside at once.

text

0.0 s Thread 4 entered
0.0 s Thread 1 entered
0.0 s Thread 3 entered
2.0 s Thread 4 is leaving
2.0 s Thread 2 entered
...
4.0 s Thread 6 is leaving
All done at 4.0 s

T = r × s = 2 × 2 = 4

Key Takeaways

Threads that share data without synchronization give wrong, changing results: count++ is read, add, write
The critical section is every line that reads and writes the shared data
lock lets one thread in at a time; it is Monitor.Enter + Exit in a try/finally
Monitor adds TryEnter (a timeout) and Wait/Pulse (taking turns)
A Semaphore lets a fixed number of threads in; a Mutex also works across programs
Only the UI thread may touch controls: use Invoke or a BackgroundWorker

Open this lesson

Mahmoud AbasC# Thread Synchronization

C# Thread Synchronization

Objectives

When Threads Share Data

Shared Resources

Worked Example: Three Threads, One Method

Three Threads, One Method: Answer

Worked Example: 10 Tickets, Two Bookings

count++ Is Three Steps

Worked Example: Three Threads, One Counter

Try It: Race Two Threads

Worked Example: Booking the Last 3 Tickets

The Critical Section

Why Synchronize?

The lock Statement

lock: Syntax

Worked Example: Welcome, with a Lock

Welcome, with a Lock: Reading the Output

Worked Example: Fixing the Counter

Worked Example: Booking with a Lock

What lock Compiles To

The IL Agrees

The IL Agrees: the finally Block

Worked Example: An Exception Inside the Lock

An Exception Inside the Lock: the catch Block

Worked Example: Monitor Without finally

Monitor Without finally: Answer

The Monitor Class

Monitor: The Methods

Worked Example: Monitor.Enter and Monitor.Exit

Monitor.Enter and Monitor.Exit: the finally Block

Monitor.Enter and Monitor.Exit: Answer

Worked Example: TryEnter with a Timeout

TryEnter with a Timeout: the finally Block

TryEnter: Answer

Taking Turns: Wait and Pulse

Worked Example: Even and Odd

Even and Odd: the Loop

Even and Odd: Answer

Try It: Inside the Monitor

Worked Example: Remove the isLast Check

Remove the isLast Check: Answer

lock or Monitor?

Exclusive and Non-Exclusive Locks

Worked Example: A Semaphore with 2 Slots

A Semaphore with 2 Slots: the Total Time

Threads and the User Interface

The Message Pump

Worked Example: Work on the UI Thread

Work on the UI Thread: Answer

Worked Example: Counting on a Worker Thread

Counting on a Worker Thread: StartCounting

The Check Only Runs Under the Debugger

The Fix: Control.Invoke

The Fix: DisplayCount on the UI Thread

The Easy Way: BackgroundWorker

Practice

Practice 1: Two Withdrawals

Practice 1: the Withdraw Method

Practice 1: Answer

Practice 2: Where Is the Lock?

Practice 2: Questions

Practice 2: Answer

Practice 3: The Shared Printer

Practice 3: Answer

Practice 4: Ping Pong

Practice 4: Answer

Practice 4: Answer, the finally Block

Practice 5: Three Slots

Key Takeaways

Open this lesson

C# Thread Synchronization

Objectives

When Threads Share Data

Shared Resources

Worked Example: Three Threads, One Method

Three Threads, One Method: Answer

Worked Example: 10 Tickets, Two Bookings

count++ Is Three Steps

Worked Example: Three Threads, One Counter

Try It: Race Two Threads

`count++` Is Three Steps

`count++` Is Three Steps