تزامن الخيوط بلغة C#

using System;
using System.Diagnostics;
using System.Threading;
 
class Program
{
    static void Main()
    {
        Stopwatch sw = Stopwatch.StartNew();
        Thread thread1 = new Thread(SomeMethod) { Name = "Thread 1" };
        Thread thread2 = new Thread(SomeMethod) { Name = "Thread 2" };
        Thread thread3 = new Thread(SomeMethod) { Name = "Thread 3" };
        thread1.Start();
        thread2.Start();
        thread3.Start();
        thread1.Join(); thread2.Join(); thread3.Join();
        Console.WriteLine("Total: " + sw.Elapsed.TotalSeconds.ToString("0.0") + " s");
    }
 
    static void SomeMethod()
    {
        Console.Write("[Welcome To The ");
        Thread.Sleep(1000);
        Console.WriteLine("World of Dotnet!]");
    }
}

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

using System;
using System.Threading;
 
class Program
{
    static int availableTickets = 10;
 
    static void Main()
    {
        Thread t1 = new Thread(() => Book(3)) { Name = "T1" };
        Thread t2 = new Thread(() => Book(2)) { Name = "T2" };
        t1.Start(); t2.Start();
        t1.Join(); t2.Join();
        Console.WriteLine("Tickets left: " + availableTickets);
    }
 
    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 and 3) write
        Console.WriteLine(name + " wrote " + availableTickets);
    }
}

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

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

using System;
using System.Threading;
 
class Program
{
    static int count = 0;
 
    static void Main()
    {
        Thread t1 = new Thread(IncrementCount);
        Thread t2 = new Thread(IncrementCount);
        Thread t3 = new Thread(IncrementCount);
        t1.Start(); t2.Start(); t3.Start();
        t1.Join(); t2.Join(); t3.Join();
        Console.WriteLine("count = " + count);
    }
 
    static void IncrementCount()
    {
        for (int i = 1; i <= 1000000; i++)
        {
            count++;
        }
    }
}

count = 2433729
count = 1646435
count = 1076791
count = 1508029
count = 1179164

using System;
using System.Threading;
 
class Program
{
    static void Main()
    {
        BookMyShow bookMyShow = new BookMyShow();
        Thread t1 = new Thread(bookMyShow.TicketBooking) { Name = "Thread1" };
        Thread t2 = new Thread(bookMyShow.TicketBooking) { Name = "Thread2" };
        Thread t3 = new Thread(bookMyShow.TicketBooking) { Name = "Thread3" };
        t1.Start(); t2.Start(); t3.Start();
        t1.Join(); t2.Join(); t3.Join();
        Console.WriteLine("Tickets left: " + bookMyShow.AvailableTickets);
    }
}
 
public class BookMyShow
{
    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);
        }
    }
 
    public void TicketBooking()
    {
        string name = Thread.CurrentThread.Name;
        if (name == "Thread1") BookTicket(name, 1);
        else if (name == "Thread2") BookTicket(name, 2);
        else BookTicket(name, 3);
    }
}

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

private static readonly object lockObject = new object();
 
static void SomeMethod()
{
    lock (lockObject)
    {
        // critical section: one thread at a time
    }
}

using System;
using System.Diagnostics;
using System.Threading;
 
class Program
{
    private static readonly object lockObject = new object();
 
    static void Main()
    {
        Stopwatch sw = Stopwatch.StartNew();
        Thread thread1 = new Thread(SomeMethod) { Name = "Thread 1" };
        Thread thread2 = new Thread(SomeMethod) { Name = "Thread 2" };
        Thread thread3 = new Thread(SomeMethod) { Name = "Thread 3" };
        thread1.Start();
        thread2.Start();
        thread3.Start();
        thread1.Join(); thread2.Join(); thread3.Join();
        Console.WriteLine("Total: " + sw.Elapsed.TotalSeconds.ToString("0.0") + " s");
    }
 
    static void SomeMethod()
    {
        string name = Thread.CurrentThread.Name;
        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");
        }
    }
}

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

using System;
using System.Threading;
 
class Program
{
    static int count = 0;
    private static readonly object lockCount = new object();
 
    static void Main()
    {
        Thread t1 = new Thread(IncrementCount);
        Thread t2 = new Thread(IncrementCount);
        Thread t3 = new Thread(IncrementCount);
        t1.Start(); t2.Start(); t3.Start();
        t1.Join(); t2.Join(); t3.Join();
        Console.WriteLine("count = " + count);
    }
 
    static void IncrementCount()
    {
        for (int i = 1; i <= 1000000; i++)
        {
            lock (lockCount)
            {
                count++;
            }
        }
    }
}

public class BookMyShow
{
    private readonly object lockObject = new object();
    public int AvailableTickets = 3;
 
    public void BookTicket(string name, int wantedTickets)
    {
        lock (lockObject)
        {
            if (wantedTickets <= AvailableTickets)
            {
                Console.WriteLine(wantedTickets + " booked to " + name);
                AvailableTickets = AvailableTickets - wantedTickets;
            }
            else
            {
                Console.WriteLine("No tickets available to book for " + name);
            }
        }
    }
 
    public void TicketBooking()
    {
        string name = Thread.CurrentThread.Name;
        if (name == "Thread1") BookTicket(name, 1);
        else if (name == "Thread2") BookTicket(name, 2);
        else BookTicket(name, 3);
    }
}

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

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

lock (lockObject)
{
    // body
}

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

static void IncrementCount()
{
    for (int i = 1; i <= 1000000; i++)
    {
        object temp = lockCount;
        bool lockTaken = false;
        try
        {
            Monitor.Enter(temp, ref lockTaken);
            count++;                       // the body of the lock
        }
        finally
        {
            if (lockTaken)
            {
                Monitor.Exit(temp);
            }
        }
    }
}

.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
}
finally
{
    ldloc.2              // lockTaken
    brfalse.s IL_0031    // false: skip Exit
    call void System.Threading.Monitor::Exit(object)
}

using System;
using System.Threading;
 
class Program
{
    private static readonly object lockObject = new object();
 
    static void Main()
    {
        Thread a = new Thread(Faulty);
        Thread b = new Thread(Other) { IsBackground = true };
        a.Start();
        a.Join();                                   // A has finished (and crashed)
        b.Start();
        bool finished = b.Join(TimeSpan.FromSeconds(2));
        Console.WriteLine("B finished within 2 s: " + finished);
    }
 
    static void Faulty()
    {
        try
        {
            lock (lockObject)
            {
                Console.WriteLine("A has the lock");
                int tickets = int.Parse("three");        // throws FormatException
            }
        }
        catch (FormatException ex)
        {
            Console.WriteLine("A caught: " + ex.Message);
        }
    }
 
    static void Other()
    {
        lock (lockObject)
        {
            Console.WriteLine("B has the lock");
        }
    }
}

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

static void Faulty()
{
    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);
    }
}

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

using System;
using System.Threading;
 
class Program
{
    private static readonly object lockPrintNumbers = new object();
 
    static void Main()
    {
        Thread[] threads = new Thread[3];
        for (int i = 0; i < threads.Length; i++)
        {
            threads[i] = new Thread(PrintNumbers) { Name = "Child Thread " + (i + 1) };
        }
        foreach (Thread t in threads) t.Start();
        foreach (Thread t in threads) t.Join();
    }
 
    static void PrintNumbers()
    {
        string name = Thread.CurrentThread.Name;
        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();
        }
        finally
        {
            Monitor.Exit(lockPrintNumbers);
            Console.WriteLine(name + " exit from the critical section");
        }
    }
}

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

static void PrintNumbers()
{
    string name = Thread.CurrentThread.Name;
    Console.WriteLine(name + " trying to enter the critical section");
    bool lockTaken = false;
    try
    {
        Monitor.Enter(lockPrintNumbers, ref lockTaken);
        if (lockTaken)
        {
            Console.WriteLine(name + " entered the critical section");
            for (int i = 0; i < 5; i++)
            {
                Thread.Sleep(100);
                Console.Write(i + ",");
            }
            Console.WriteLine();
        }
    }
    finally
    {
        if (lockTaken)
        {
            Monitor.Exit(lockPrintNumbers);
            Console.WriteLine(name + " exit from the critical section");
        }
    }
}

static void PrintNumbers()
{
    string name = Thread.CurrentThread.Name;
    Console.WriteLine(name + " trying to enter the critical section");
    TimeSpan timeout = TimeSpan.FromSeconds(1);
    bool lockTaken = false;
    try
    {
        Monitor.TryEnter(lockPrintNumbers, timeout, ref lockTaken);
        if (lockTaken)
        {
            Console.WriteLine(name + " entered the critical section");
            for (int i = 0; i < 5; i++)
            {
                Thread.Sleep(100);
                Console.Write(i + ",");
            }
            Console.WriteLine();
        }
        else
            Console.WriteLine(name + ": lock was not acquired");
    }
    finally
    {
        if (lockTaken)
        {
            Monitor.Exit(lockPrintNumbers);
            Console.WriteLine(name + " exit from the critical section");
        }
    }
}

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

using System;
using System.Threading;
 
class Program
{
    const int numberLimit = 20;
    private static readonly object lockMonitor = new object();
 
    static void Main()
    {
        Thread evenThread = new Thread(PrintEvenNumbers);
        Thread oddThread = new Thread(PrintOddNumbers);
        evenThread.Start();
        Thread.Sleep(100);        // make sure the even thread starts first
        oddThread.Start();
        oddThread.Join();
        evenThread.Join();
        Console.WriteLine();
        Console.WriteLine("Main method completed");
    }
 
    static void PrintEvenNumbers()
    {
        try
        {
            Monitor.Enter(lockMonitor);
            for (int i = 0; i <= numberLimit; i = i + 2)
            {
                Console.Write(i + " ");
                Monitor.Pulse(lockMonitor);         // tell the other thread: get ready
                bool isLast = (i == numberLimit);
                if (!isLast)
                    Monitor.Wait(lockMonitor);      // release the lock and wait
            }
        }
        finally { Monitor.Exit(lockMonitor); }
    }
 
    static void PrintOddNumbers()
    {
        try
        {
            Monitor.Enter(lockMonitor);
            for (int i = 1; i <= numberLimit; i = i + 2)
            {
                Console.Write(i + " ");
                Monitor.Pulse(lockMonitor);
                bool isLast = (i == numberLimit - 1);
                if (!isLast)
                    Monitor.Wait(lockMonitor);
            }
        }
        finally { Monitor.Exit(lockMonitor); }
    }
}

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

using System;
using System.Threading;
 
class Program
{
    const int numberLimit = 20;
    private static readonly object lockMonitor = new object();
 
    static void Main()
    {
        Thread evenThread = new Thread(PrintEvenNumbers) { IsBackground = true };
        Thread oddThread = new Thread(PrintOddNumbers) { IsBackground = true };
        evenThread.Start();
        Thread.Sleep(100);        // make sure the even thread starts first
        oddThread.Start();
        bool oddDone = oddThread.Join(TimeSpan.FromSeconds(2));
        bool evenDone = evenThread.Join(TimeSpan.FromSeconds(2));
        Console.WriteLine();
        Console.WriteLine("odd finished: " + oddDone + ", even finished: " + evenDone);
    }
 
    static void PrintEvenNumbers()
    {
        try
        {
            Monitor.Enter(lockMonitor);
            for (int i = 0; i <= numberLimit; i = i + 2)
            {
                Console.Write(i + " ");
                Monitor.Pulse(lockMonitor);         // tell the other thread: get ready
                Monitor.Wait(lockMonitor);          // no isLast check
            }
        }
        finally
        {
            Monitor.Exit(lockMonitor);
        }
    }
 
    static void PrintOddNumbers()
    {
        try
        {
            Monitor.Enter(lockMonitor);
            for (int i = 1; i <= numberLimit; i = i + 2)
            {
                Console.Write(i + " ");
                Monitor.Pulse(lockMonitor);
                Monitor.Wait(lockMonitor);          // no isLast check
            }
        }
        finally
        {
            Monitor.Exit(lockMonitor);
        }
    }
}

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

using System;
using System.Threading;
 
class Program
{
    static Mutex mutex = new Mutex();
    static int count = 0;
 
    static void Main()
    {
        Thread t1 = new Thread(Inc) { Name = "Thread 1" };
        Thread t2 = new Thread(Inc) { Name = "Thread 2" };
        t1.Start(); t2.Start();
        t1.Join(); t2.Join();
    }
 
    static void Inc()
    {
        mutex.WaitOne();                          // acquire
        count++;
        Console.WriteLine(Thread.CurrentThread.Name + " -> " + count);
        mutex.ReleaseMutex();                     // release
    }
}

Thread 1 -> 1
Thread 2 -> 2

using System;
using System.Diagnostics;
using System.Threading;
 
class Program
{
    static Semaphore sm = new Semaphore(2, 2);   // 2 free slots, at most 2
    static Stopwatch sw = Stopwatch.StartNew();
 
    static void Main()
    {
        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++)
        {
            threads[i] = new Thread(Work) { Name = "Thread " + (i + 1) };
            threads[i].Start();
        }
        foreach (Thread t in threads) t.Join();
        Console.WriteLine("All done at " + Now());
    }
 
    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
    }
 
    static string Now()
    {
        return sw.Elapsed.TotalSeconds.ToString("0.0") + " s";
    }
}

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

while (msg = get_next_message())
{
    dispatch_message(msg);
}

namespace SyncDemo
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        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";
        }
    }
}

private void button1_Click(object sender, EventArgs e)
{
    var thread = new Thread(StartCounting);
    thread.IsBackground = true;
    thread.Start();
}
 
private void StartCounting()
{
    for (var i = 0; i < 10; i++)
    {
        textBox1.Text = i.ToString();
        Thread.Sleep(1000);
    }
}

Unhandled exception. System.InvalidOperationException: Cross-thread operation not valid: Control 'textBox1' accessed from a thread other than the thread it was created on.

Control.CheckForIllegalCrossThreadCalls = true;   // what F5 (debugging) does

namespace SyncDemo
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private delegate void DisplayCountDelegate(int i);
        private delegate void EnableButtonDelegate();
 
        private void button1_Click(object sender, EventArgs e)
        {
            var thread = new Thread(StartCounting);
            thread.IsBackground = true;
            thread.Start();
            button1.Enabled = false;
        }
 
        private void StartCounting()
        {
            for (var i = 0; i < 10; i++)
            {
                textBox1.Invoke(new DisplayCountDelegate(DisplayCount), i);
                Thread.Sleep(1000);
            }
            button1.Invoke(new EnableButtonDelegate(EnableButton));
        }
 
        private void DisplayCount(int i)
        {
            textBox1.Text = i.ToString();
        }
 
        private void EnableButton()
        {
            button1.Enabled = true;
        }
    }
}

using System.ComponentModel;
 
namespace SyncDemo
{
    public partial class Form1 : Form
    {
        private readonly BackgroundWorker worker;
 
        public Form1()
        {
            InitializeComponent();
 
            worker = new BackgroundWorker();
            worker.WorkerReportsProgress = true;
            worker.DoWork += StartCounting;
            worker.ProgressChanged += worker_ProgressChanged;
            worker.RunWorkerCompleted += worker_RunWorkerCompleted;
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            worker.RunWorkerAsync();
            button1.Enabled = false;
        }
 
        private void StartCounting(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker bgWorker = (BackgroundWorker)sender;
            for (var i = 0; i < 10; i++)
            {
                bgWorker.ReportProgress(i);
                Thread.Sleep(1000);
            }
        }
 
        private void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            textBox1.Text = e.ProgressPercentage.ToString();
        }
 
        private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            button1.Enabled = true;
            label1.Text = "Completed";
        }
    }
}

using System;
using System.Threading;
 
class Program
{
    static int balance = 500;
 
    static void Main()
    {
        Thread t1 = new Thread(() => Withdraw(300)) { Name = "ATM" };
        Thread t2 = new Thread(() => Withdraw(400)) { Name = "App" };
        t1.Start(); t2.Start();
        t1.Join(); t2.Join();
        Console.WriteLine("Balance: " + balance);
    }
 
    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");
        }
    }
}

// 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; }
}

using System;
using System.Threading;
 
class Program
{
    private static readonly object lockPrinter = new object();
 
    static void Main()
    {
        Thread[] threads = new Thread[4];
        for (int i = 0; i < 4; i++)
        {
            threads[i] = new Thread(Print) { Name = "T" + (i + 1) };
            threads[i].Start();
        }
        foreach (Thread t in threads) t.Join();
    }
 
    static void Print()
    {
        string name = Thread.CurrentThread.Name;
        bool lockTaken = false;
        try
        {
            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");
            }
        }
        finally
        {
            if (lockTaken)
            {
                Monitor.Exit(lockPrinter);
            }
        }
    }
}

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

ATM withdraws 300
App withdraws 400
Balance: -200

static void Withdraw(int amount)
{
    string name = Thread.CurrentThread.Name;
    lock (lockBalance)
    {
        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");
        }
    }
}

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

using System;
using System.Threading;
 
class Program
{
    const int rounds = 5;
    private static readonly object lockBall = new object();
 
    static void Main()
    {
        Thread ping = new Thread(() => Play("ping"));
        Thread pong = new Thread(() => Play("pong"));
        ping.Start();
        Thread.Sleep(100);                        // ping must serve first
        pong.Start();
        ping.Join();
        pong.Join();
        Console.WriteLine();
        Console.WriteLine("Game over");
    }
 
    static void Play(string word)
    {
        try
        {
            Monitor.Enter(lockBall);
            for (int i = 1; i <= rounds; i++)
            {
                Console.Write(word + " ");
                Monitor.Pulse(lockBall);          // wake the other player
                if (i != rounds)
                    Monitor.Wait(lockBall);       // hand the ball over and wait
            }
        }
        finally
        {
            Monitor.Exit(lockBall);
        }
    }
}

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
2.0 s Thread 1 is leaving
2.0 s Thread 5 entered
2.0 s Thread 3 is leaving
2.0 s Thread 6 entered
4.0 s Thread 2 is leaving
4.0 s Thread 5 is leaving
4.0 s Thread 6 is leaving
All done at 4.0 s