MSDN Documentation

C# Threading

This document provides a comprehensive overview of threading concepts in C# and the .NET Framework.

Introduction to Threading

Threading allows your application to perform multiple tasks concurrently. This can significantly improve application responsiveness and performance, especially for I/O-bound operations or CPU-intensive computations.

A thread is the smallest unit of execution within a process. A process can have multiple threads, each executing independently.

The System.Threading Namespace

The primary namespace for managing threads in .NET is System.Threading. This namespace contains classes like:

Creating and Starting Threads

You can create a new thread by instantiating the Thread class and providing a method to be executed by the thread.


using System;
using System.Threading;

public class Example
{
    public static void ThreadMethod()
    {
        Console.WriteLine("Hello from the new thread!");
    }

    public static void Main()
    {
        Thread newThread = new Thread(ThreadMethod);
        newThread.Start(); // Starts the execution of the thread
        Console.WriteLine("Main thread finished.");
    }
}

The Start() method begins the thread's execution. The thread will then run the ThreadMethod concurrently with the main thread.

Thread States

Threads can be in various states, including:

Thread Synchronization

When multiple threads access shared data, you must ensure data integrity and prevent race conditions. .NET provides several synchronization mechanisms:

1. lock Statement

The lock statement provides a simple way to create a mutually exclusive section, ensuring that only one thread can execute a block of code at a time.


private static readonly object _lockObject = new object();
private static int _sharedCounter = 0;

public static void IncrementCounter()
{
    lock (_lockObject)
    {
        _sharedCounter++;
        Console.WriteLine($"Counter: {_sharedCounter}");
    }
}

2. Mutex

Mutex (Mutual Exclusion) is similar to lock but can be used across different processes.

3. Semaphore and SemaphoreSlim

These classes limit the number of threads that can access a resource or a pool of resources concurrently.

Thread Pool

Instead of creating and destroying threads frequently, which can be resource-intensive, you can use the ThreadPool. The thread pool manages a collection of worker threads that are reused for executing tasks.


public static void ProcessData(object data)
{
    Console.WriteLine($"Processing: {data} on thread {Thread.CurrentThread.ManagedThreadId}");
    Thread.Sleep(1000); // Simulate work
}

public static void Main()
{
    for (int i = 0; i < 10; i++)
    {
        ThreadPool.QueueUserWorkItem(ProcessData, $"Item {i}");
    }
    Console.WriteLine("All tasks queued.");
    Thread.Sleep(5000); // Give threads time to complete
}

Using the thread pool is generally more efficient for background tasks that don't require specific thread properties like priority.

Asynchronous Programming (async / await)

For I/O-bound operations, the async and await keywords provide a higher-level, more readable way to handle asynchronous operations without explicitly managing threads.


public async Task DownloadDataAsync(string url)
{
    using (var client = new System.Net.Http.HttpClient())
    {
        return await client.GetStringAsync(url);
    }
}

While async/await doesn't directly expose thread management, it leverages the thread pool and TPL (Task Parallel Library) under the hood to achieve concurrency.

Task Parallel Library (TPL)

The TPL, introduced in .NET Framework 4, provides a higher-level abstraction for parallelism and concurrency. It includes types like Task and Parallel.

Parallel.For and Parallel.ForEach

These methods allow you to easily parallelize loops.


string[] data = { "A", "B", "C", "D", "E" };

Parallel.ForEach(data, item =>
{
    Console.WriteLine($"Processing {item} on thread {Thread.CurrentThread.ManagedThreadId}");
    Thread.Sleep(500);
});

Best Practices

Further Reading