Walk me through the lifecycle of a .NET thread. What states can it be in, and what happens on each transition?

1. State diagram

          new Thread()
               |
           Unstarted
               | Start()
               v
   +------> Running <---------------------------+
   |           |  Sleep / Join / lock / WaitOne |
   |           v                                | signal / timeout / Interrupt()
   |      WaitSleepJoin ------------------------+
   |           
   |  delegate returns or throws
   +---------> Stopped   (Start() again -> ThreadStateException)

2. What "blocked" really is

When a thread enters WaitSleepJoin, the CLR typically spins briefly (for Monitor and *Slim primitives) and then calls into the OS to wait on a kernel object. The OS removes the thread from its run queue. Waking it means a context switch: saving and restoring registers and often losing cache warmth. That's why short critical sections plus brief spinning outperform immediate blocking.

CLR-aware waits are also alertable in the managed sense: Interrupt() can break them, and the GC can suspend a thread in a managed wait safely.

3. ThreadState is a snapshot

if (worker.ThreadState == ThreadState.Running)  // may already be Stopped by the next line
    DoSomething();

Correct coordination tools:

4. Interrupt semantics

• If the target is in a managed blocking wait, it wakes with ThreadInterruptedException.
• If it isn't blocked, the interrupt is remembered and thrown at its next managed wait.
• It can break waits inside libraries that don't expect it, leaving them inconsistent; that's why cooperative cancellation is preferred.

5. Process termination rules

In generic-host apps, IHostApplicationLifetime.ApplicationStopping plus BackgroundService.StopAsync gives you a structured shutdown instead.

6. Observing states in a dump

> dotnet-dump analyze crash.dmp
> clrthreads           # lists managed threads, IDs, apartment, lock count, exception
> setthread <n>
> clrstack             # what the thread is doing / waiting on
> syncblk              # which thread owns contended Monitor locks

A thread whose top frame is Monitor.Enter, WaitHandle.WaitOne or Thread.Sleep is in WaitSleepJoin.

7. Version notes

8. Try it yourself

1. Run the code example and note each printed state.
2. Call Interrupt() before the thread sleeps (start it with a busy loop first) and confirm the exception is thrown at the next wait.
3. Remove the try/catch and see the whole process terminate.
4. Make the thread foreground, never interrupt it, and observe the process not exiting.
5. Throw inside Task.Run vs inside ThreadPool.QueueUserWorkItem and compare: one is captured, the other kills the process.
6. Take a dump while the thread sleeps and inspect it with clrthreads and clrstack.

using System.Threading;

var worker = new Thread(() =>
{
    try
    {
        Thread.Sleep(Timeout.Infinite); // enters WaitSleepJoin
    }
    catch (ThreadInterruptedException)
    {
        Console.WriteLine("Woken by Interrupt");
    }
})
{ IsBackground = true, Name = "sleeper" };

Console.WriteLine(worker.ThreadState);   // Unstarted, Background
worker.Start();
Thread.Sleep(100);
Console.WriteLine(worker.ThreadState);   // WaitSleepJoin, Background

worker.Interrupt();
worker.Join();
Console.WriteLine(worker.ThreadState);   // Stopped, Background

try
{
    worker.Start();
}
catch (ThreadStateException ex)
{
    Console.WriteLine($"Cannot restart: {ex.GetType().Name}");
}