What is the difference between a process and a thread? How do they map to .NET concepts such as Process, Thread, the thread pool and Task?

1. Picture a process with three threads

Process 4312 (MyApi)
+---------------------------------------------------------------+
| virtual address space                                         |
|   code (JIT + native) | GC heap | native heap | mapped files   |
|                                                               |
|   thread 1 stack | thread 2 stack | thread 3 stack           |
|                                                               |
| handle table: files, sockets, events, threads                 |
| security token / uid                                          |
+---------------------------------------------------------------+
   thread 1: registers, IP  thread 2: registers, IP  thread 3: ...
   all three see the same GC heap and statics

2. Linux and Windows details

• Linux implements threads as tasks that share an address space (created with clone). Tools like top -H and ps -L show threads.
• Windows has process and thread objects in the kernel; Task Manager and Process Explorer show threads per process.
• .NET threads have a managed ID (Environment.CurrentManagedThreadId) and an OS thread ID; debuggers and dotnet-dump show both.

3. The thread pool in brief

• Starts with a minimum number of workers (by default, the processor count) and injects more when work is queued and threads are blocked, using a hill-climbing algorithm (roughly one or two new threads per second beyond the minimum).
• Blocking calls on pool threads (.Result, .Wait(), synchronous I/O) cause thread pool starvation: requests queue while the pool slowly grows.
• ThreadPool.GetAvailableThreads, dotnet-counters (threadpool-thread-count, threadpool-queue-length) show the state.

4. Tasks are not threads

await httpClient.GetAsync(url)
   1. start the request (a few microseconds on a pool thread)
   2. return to the caller; the pool thread is free
   3. ... network round trip: NO thread is waiting ...
   4. the OS signals completion (IOCP / epoll); a pool thread runs the continuation

Task.Run(() => CpuWork()) does use a pool thread for the duration of the work. Know which kind of task you have.

5. Process-level concerns in production

6. Try it yourself

1. Write a console app that starts three Threads printing their managed and OS thread IDs (Environment.CurrentManagedThreadId and, on Linux, /proc/thread-self or top -H), then compare with three Task.Run calls.
2. Await 1,000 concurrent Task.Delay(1000) calls and watch the thread count in dotnet-counters: it barely moves.
3. Replace the delays with Thread.Sleep(1000) inside Task.Run and watch the thread pool grow slowly, then explain why.
4. Start a child process with Process.Start and communicate with it over standard input and output.

namespace ProcessesAndThreads;

using System.Diagnostics;

public static class Program
{
    public static async Task Main()
    {
        using var current = Process.GetCurrentProcess();
        Console.WriteLine($"Process {current.Id} has {current.Threads.Count} OS threads");

        // Dedicated OS thread (rarely needed)
        var worker = new Thread(() => Console.WriteLine($"Dedicated thread {Environment.CurrentManagedThreadId}"))
        {
            IsBackground = true,
            Name = "dedicated-worker",
        };
        worker.Start();
        worker.Join();

        // Thread pool work (CPU-bound)
        int result = await Task.Run(() => Enumerable.Range(0, 1_000_000).Sum(i => i % 7));
        Console.WriteLine($"CPU work result {result}");

        // 1,000 concurrent waits use almost no threads
        var sw = Stopwatch.StartNew();
        await Task.WhenAll(Enumerable.Range(0, 1_000).Select(_ => Task.Delay(1_000)));
        current.Refresh();
        Console.WriteLine($"1,000 delays in {sw.ElapsedMilliseconds} ms with {current.Threads.Count} OS threads");

        // A separate process for isolation
        var info = new ProcessStartInfo("dotnet", "--version") { RedirectStandardOutput = true };
        using var child = Process.Start(info)!;
        string version = await child.StandardOutput.ReadToEndAsync();
        await child.WaitForExitAsync();
        Console.WriteLine($"Child process {child.Id} reported SDK {version.Trim()}");
    }
}