📝 Lesson 2.1: Threads, the Thread Pool, and Tasks

Concurrency vs. Parallelism

These related terms are worth pinning down precisely:

An analogy: one chef juggling three dishes by switching between them is concurrency; three chefs each cooking a dish simultaneously is parallelism. Threads are the chefs; cores are the stoves.

Crucially, threads in a process share the same memory (the heap). That's what makes them powerful — and dangerous, as we'll see in Lesson 2.2 on thread safety.

Raw Threads

The lowest-level tool is the Thread class. You give it a method to run, Start() it, and optionally Join() to wait for it:

using System.Threading;

Thread worker = new Thread(() =>
{
    for (int i = 0; i < 3; i++)
    {
        Console.WriteLine($"Worker: {i}");
        Thread.Sleep(100);
    }
});

worker.Start();                     // begins running on a new thread
Console.WriteLine("Main continues...");
worker.Join();                      // block until 'worker' finishes
Console.WriteLine("Worker done.");

The Thread Pool

Creating and destroying threads is costly, but most tasks are short. The thread pool solves this: .NET keeps a managed pool of reusable worker threads. You hand it work; it runs that work on an available thread, then returns the thread to the pool for reuse.

You could queue work directly (ThreadPool.QueueUserWorkItem), but that API is low-level and gives you no easy way to get a result or know when it's done. That's exactly the gap Task fills.

Task.Run

A Task (from Intermediate async) is a high-level handle to work that's running or will run. Task.Run schedules a delegate to execute on the thread pool and hands you a Task to track it — the modern, preferred way to push CPU-bound work off the current thread:

// Offload a CPU-heavy computation to a pool thread
Task<long> work = Task.Run(() =>
{
    long sum = 0;
    for (int i = 0; i < 1_000_000; i++) sum += i;
    return sum;
});

Console.WriteLine("Main thread stays responsive...");
long result = await work;          // await the result (Lesson 4.3)
Console.WriteLine($"Sum = {result}");

Because Task.Run returns a Task<T>, everything you learned about await, Task.WhenAll, and exceptions applies. Run several CPU-bound jobs across cores at once:

Task<long>[] jobs =
{
    Task.Run(() => Compute(0, 250_000)),
    Task.Run(() => Compute(250_000, 500_000)),
    Task.Run(() => Compute(500_000, 750_000)),
    Task.Run(() => Compute(750_000, 1_000_000))
};

long[] partials = await Task.WhenAll(jobs);   // run on multiple cores
Console.WriteLine($"Total = {partials.Sum()}");

static long Compute(int start, int end)
{
    long sum = 0;
    for (int i = start; i < end; i++) sum += i;
    return sum;
}

CPU-bound vs. I/O-bound

This distinction decides which tool to use, and it's the single most important idea in the module.

💡 The rule: If the work keeps a CPU busy, give it a thread (Task.Run). If the work is waiting for something external, use async/await and don't burn a thread on the wait. Threads are precious — spend them only on actual computation.

Exercise & Quiz

using System.Diagnostics;

// Sequential
var sw = Stopwatch.StartNew();
int total = CountPrimes(2, 500_000);
sw.Stop();
Console.WriteLine($"Sequential: {total} primes in {sw.ElapsedMilliseconds} ms");

// TODO: parallel with 4 Task.Run chunks + Task.WhenAll, then time and compare

static bool IsPrime(int n)
{
    if (n < 2) return false;
    for (int i = 2; (long)i * i <= n; i++)
        if (n % i == 0) return false;
    return true;
}

static int CountPrimes(int start, int end)
{
    int count = 0;
    for (int i = start; i < end; i++)
        if (IsPrime(i)) count++;
    return count;
}

using System.Diagnostics;

var sw = Stopwatch.StartNew();
int total = CountPrimes(2, 500_000);
sw.Stop();
Console.WriteLine($"Sequential: {total} primes in {sw.ElapsedMilliseconds} ms");

sw.Restart();
Task<int>[] tasks =
{
    Task.Run(() => CountPrimes(2,       125_000)),
    Task.Run(() => CountPrimes(125_000, 250_000)),
    Task.Run(() => CountPrimes(250_000, 375_000)),
    Task.Run(() => CountPrimes(375_000, 500_000))
};
int[] parts = await Task.WhenAll(tasks);
sw.Stop();
Console.WriteLine($"Parallel:   {parts.Sum()} primes in {sw.ElapsedMilliseconds} ms");

static bool IsPrime(int n)
{
    if (n < 2) return false;
    for (int i = 2; (long)i * i <= n; i++)
        if (n % i == 0) return false;
    return true;
}

static int CountPrimes(int start, int end)
{
    int count = 0;
    for (int i = start; i < end; i++)
        if (IsPrime(i)) count++;
    return count;
}

Summary

📚 Additional Resources

• Managed threading — Microsoft Docs
• Task.Run — API reference
• The managed thread pool

🚀 What's Next?

Multiple threads sharing memory is powerful — and perilous. In Lesson 2.2: Thread Safety and Synchronization, you'll see how concurrent access corrupts data, and learn lock, Interlocked, and concurrent collections to prevent it.