What is a Thread in .NET, and when would you still create one directly instead of using Task.Run or the ThreadPool?

1. From new Thread to running code

new Thread(start)      -> managed Thread object only (no OS thread yet)
thread.Start()         -> CLR creates OS thread (CreateThread / pthread_create)
                          OS thread starts in CLR's thread entry
                          CLR sets up: allocation context, ExecutionContext (unless UnsafeStart),
                          culture, then invokes your delegate
delegate returns       -> CLR tears down per-thread state; OS thread exits
                          Join() callers wake up

Start returns once the OS thread exists; it does not wait for your delegate to start running.

2. ExecutionContext flow

By default, Start() captures the current ExecutionContext (which carries AsyncLocal<T> values such as an Activity or a logging scope) and runs the delegate inside it. For a thread that lives for the whole process, that can pin request-specific data forever. UnsafeStart() (or ExecutionContext.SuppressFlow()) starts the thread with a clean context.

3. Stack size

var t = new Thread(DeepRecursion, maxStackSize: 16 * 1024 * 1024); // 16 MB

• Reserved, not committed: memory is only touched as the stack grows.
• Exceeding the stack causes a StackOverflowException, which cannot be caught and kills the process.
• The default can also be changed process-wide with runtime configuration (DOTNET_DefaultStackSize, hex), rarely needed.

4. Why Thread.Abort was removed

Abort injected a ThreadAbortException at an arbitrary instruction: inside a lock, halfway through updating shared state, during a static constructor (which then failed permanently for the type). There's no way to write code that's robust to that everywhere. .NET Core removed it; cooperative cancellation is the replacement:

while (!token.IsCancellationRequested)
{
    var msg = client.Receive(timeout: TimeSpan.FromMilliseconds(500)); // bounded blocking
    if (msg is not null) Handle(msg);
}

If the blocking call has no timeout or cancellation support, closing the underlying resource (socket, connection) from another thread is usually the way to unblock it.

5. Threads vs pool threads under a debugger

Naming dedicated threads is free and saves time in every incident.

6. Version notes

7. Try it yourself

1. Run the code example and find the thread with dotnet-stack report -p <pid>; confirm it shows its name.
2. Change it to Task.Run and see it become an anonymous pool worker.
3. Remove IsBackground = true, press Enter without cancelling, and observe the process not exiting.
4. Call reader.Abort() and observe PlatformNotSupportedException.
5. Start 2,000 threads that each Thread.Sleep(Timeout.Infinite) and compare process memory and GC.GetTotalPauseDuration() before and after a few GC.Collect() calls.
6. Set an AsyncLocal<string> value, start a thread with Start() and another with UnsafeStart(), and print the value in each.

using System.Threading;

var cts = new CancellationTokenSource();

// Dedicated, named, background thread for a blocking legacy loop.
var reader = new Thread(() => ReadLoop(cts.Token))
{
    Name = "vendor-feed-reader",
    IsBackground = true // do not keep the process alive on shutdown
};
reader.Start();

Console.WriteLine("Press Enter to stop");
Console.ReadLine();

cts.Cancel();               // cooperative stop, never Thread.Abort
reader.Join(TimeSpan.FromSeconds(5));
Console.WriteLine($"Reader alive after join: {reader.IsAlive}");

static void ReadLoop(CancellationToken token)
{
    while (!token.IsCancellationRequested)
    {
        // Stand-in for a blocking vendor call such as client.Receive().
        Thread.Sleep(200);
        Console.WriteLine($"[{Thread.CurrentThread.Name}] message read");
    }
}