Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

interview

home / developersection / interviews / how does async/await interact with threads in c#?
Ask Question

How does async/await interact with threads in C#?

Ravi Vishwakarma 848 06 Mar 2025
c# c#
Updated 06 Mar 2025
Ravi Vishwakarma
Ravi Vishwakarma

IT-Hardware & Networking

Ravi Vishwakarma is a dedicated Software Developer with a passion for crafting efficient and innovative solutions. With a keen eye for detail and years of experience, he excels in developing robust software systems that meet client needs. His expertise spans across multiple programming languages and technologies, making him a valuable asset in any software development project.

Message

1 Answers

Ravi Vishwakarma
Ravi Vishwakarma 06 Mar 2025
Report Abuse

How async/await Interacts with Threads in C#

The async/await mechanism in C# does not create new threads but instead utilizes asynchronous programming to avoid blocking the current thread while waiting for an operation to complete.

Ravi Vishwakarma

1. Key Concepts

Concept Explanation
Async Method A method marked with async, which can contain await statements.
Await Suspends execution of the method and returns control to the caller until the awaited task completes.
Task-Based Asynchronous Pattern (TAP) async/await is built on Task<T> and Task.
Thread Pool Managed by .NET (ThreadPool), where asynchronous work is scheduled.

2. How async/await Uses Threads

Scenario 1: I/O-Bound (Non-Blocking)

Example: Reading a file asynchronously

using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Reading file...");
        string content = await ReadFileAsync();
        Console.WriteLine("File content length: " + content.Length);
    }

    static async Task<string> ReadFileAsync()
    {
        using StreamReader reader = new StreamReader("example.txt");
        return await reader.ReadToEndAsync(); // Non-blocking I/O operation
    }
}

How it works:

  • No additional threads are created.
  • ReadToEndAsync() does not block the main thread. Instead, it awaits completion using OS-level async I/O.
  • While waiting, the main thread is free to handle other work.

Scenario 2: CPU-Bound (Runs on ThreadPool)

Example: Performing heavy calculations asynchronously

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine($"Main thread: {Thread.CurrentThread.ManagedThreadId}");
        
        int result = await Task.Run(() => ExpensiveCalculation());
        
        Console.WriteLine($"Result: {result}");
        Console.WriteLine($"Main thread after await: {Thread.CurrentThread.ManagedThreadId}");
    }

    static int ExpensiveCalculation()
    {
        Console.WriteLine($"Calculation on thread { Thread.CurrentThread.ManagedThreadId }");
        Thread.Sleep(3000); // Simulate heavy work
        return 42;
    }
}

How it works:

  • Task.Run() creates a new thread from the ThreadPool to execute ExpensiveCalculation().
  • After await, execution resumes on the original thread (main thread).
  • Useful for CPU-bound tasks that need to run without blocking the UI/main thread.

3. Threading Behavior in UI Applications (ASP.NET & WinForms/WPF)

ASP.NET Core (No Synchronization Context)

public async Task<IActionResult> GetData()
{
    string data = await GetRemoteDataAsync();
    return Ok(data);
}
  1. No UI thread exists, so await continues execution on a ThreadPool thread.
  2. Avoid Task.Run() for I/O-bound work since ASP.NET handles it efficiently.

WinForms/WPF (Synchronization Context Exists)

private async void Button_Click(object sender, RoutedEventArgs e)
{
    label.Content = "Loading...";
    string data = await GetRemoteDataAsync(); // Resumes on the UI thread
    label.Content = data;
}
  1. Execution resumes on the original UI thread after await.
  2. Avoid blocking UI threads with .Result or .Wait().

4. Threading Behavior Summary

Scenario Does it Use New Threads? Execution Resumes On
I/O-bound (e.g., file, DB, API calls) No new threads Original thread
CPU-bound (Task.Run) Yes (ThreadPool) Original thread (UI) or ThreadPool (ASP.NET Core)
ASP.NET Core No new threads for I/O ThreadPool thread
WinForms/WPF No new threads for I/O UI thread

Summary

  1. async/await does not create threads; it asynchronously waits.
  2. I/O-bound work (file, DB, API) does not use new threads—it just awaits completion.
  3. CPU-bound work should use Task.Run() to offload work to ThreadPool threads.
  4. WinForms/WPF resumes on UI thread, whereas ASP.NET Core resumes on a ThreadPool thread.
  5. Avoid .Result, .Wait(), or Task.Run() for async I/O.
advertising