Creating and Running Threads in C#

A **Thread** is the smallest unit of execution in a process. In C#, threads allow **parallel execution of tasks**, improving performance in multi-core systems. The **System.Threading** namespace provides classes for thread management.

Key Features of Threads

Allows **parallel execution** of tasks.
Shares **memory space** with other threads in the same process.
Can be **created, started, paused, and stopped**.
Supports **synchronization techniques** to prevent data inconsistency.

Creating and Running a Thread

The **Thread** class in C# allows creating and running threads using the **Start()** method.

Example: Creating and Running a Thread

using System;
using System.Threading;

class Program
{
    static void PrintNumbers()
    {
        for (int i = 1; i <= 5; i++)
        {
            Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} prints {i}");
            Thread.Sleep(500);
        }
    }

    static void Main()
    {
        // Create a new thread
        Thread thread1 = new Thread(PrintNumbers);
        thread1.Start();

        // Main thread execution
        PrintNumbers();
    }
}

// Output:
// Thread 1 prints 1
// Thread 2 prints 1
// Thread 1 prints 2
// Thread 2 prints 2
// ...

The **Thread.Start()** method starts the execution of a new thread while the main thread continues running in parallel.

Parameterized Threads

You can pass parameters to a thread method using **ParameterizedThreadStart**.

Example: Passing Parameters to a Thread

using System;
using System.Threading;

class Program
{
    static void PrintMessage(object message)
    {
        Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} received: {message}");
    }

    static void Main()
    {
        Thread thread = new Thread(PrintMessage);
        thread.Start("Hello from thread!");
    }
}

// Output:
// Thread 3 received: Hello from thread!

The **ParameterizedThreadStart** delegate allows passing an argument to the thread function.

Using Lambda Expressions with Threads

Instead of defining a separate method, you can use **lambda expressions** to create threads.

Example: Lambda Expression in Thread Creation

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // Creating a thread using a lambda expression
        Thread thread = new Thread(() =>
        {
            for (int i = 1; i <= 5; i++)
            {
                Console.WriteLine($"Lambda Thread prints {i}");
                Thread.Sleep(500);
            }
        });

        thread.Start();
    }
}

// Output:
// Lambda Thread prints 1
// Lambda Thread prints 2
// ...

Lambda expressions simplify thread creation for short tasks.

Thread Lifecycle Management

A thread has different states: **Unstarted, Running, Suspended, Stopped, and Aborted**.

Example: Managing Thread Lifecycle

using System;
using System.Threading;

class Program
{
    static void PrintNumbers()
    {
        for (int i = 1; i <= 3; i++)
        {
            Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} prints {i}");
            Thread.Sleep(500);
        }
    }

    static void Main()
    {
        Thread thread = new Thread(PrintNumbers);
        thread.Start();

        thread.Join();  // Waits for thread to complete
        Console.WriteLine("Thread execution completed.");
    }
}

// Output:
// Thread 1 prints 1
// Thread 1 prints 2
// Thread 1 prints 3
// Thread execution completed.

The **Join()** method ensures that the main thread waits until the child thread completes.

Best Practices for Threading

Use **Thread.Join()** to wait for a thread to finish execution.
Avoid **excessive thread creation** to prevent performance issues.
Use **locks, mutexes, or semaphores** for thread synchronization.
For **asynchronous programming**, consider using the **Task Parallel Library (TPL)** instead.