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 AI Tools Integration
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 Interviews What is a deadlock and how can you prevent it in .NET? – MindStick
Ask Question

1 Answers

ICSM Computer
ICSM Computer 12 Jun 2025
Report Abuse

What is a Deadlock in .NET?

A deadlock occurs when two or more threads are waiting for each other to release a resource, and none of them can proceed, resulting in an application hang.

In .NET, deadlocks typically happen when:

  • Multiple threads acquire locks in different orders.
  • An async method is blocked synchronously using .Result or .Wait().

Common Example: Async Deadlock

Problem Code

public string GetData()
{
    return GetDataAsync().Result; // BLOCKING call
}

public async Task<string> GetDataAsync()
{
    await Task.Delay(1000); // Captures SynchronizationContext (UI thread)
    return "Done";
}

What Happens

  • GetData() blocks the main thread using .Result.
  • GetDataAsync() awaits Task.Delay and tries to resume on the main thread.
  • But the main thread is blocked, so it can't resume → Deadlock.

Fix: Use await all the way

public async Task<string> GetDataSafeAsync()
{
    await Task.Delay(1000);
    return "Done";
}

And call it like this:

var result = await GetDataSafeAsync();

Deadlock in Locking Code (Multi-threaded Deadlock)

Example:

lock (lockA)
{
    lock (lockB)
    {
        // do work
    }
}

Another thread does:

lock (lockB)
{
    lock (lockA)
    {
        // do work
    }
}

Deadlock Risk:

  1. Thread 1 holds lockA, waits for lockB
  2. Thread 2 holds lockB, waits for lockA
    → both are stuck waiting on each other

Prevention Strategies

For Async Deadlocks:

Rule Description
Use await Don’t block async code with .Wait() or .Result
ConfigureAwait(false) In libraries, use await SomeTask.ConfigureAwait(false) to avoid context capture
Make methods fully async Async all the way from top to bottom

For Thread Deadlocks:

Rule Description
Lock ordering Always acquire locks in the same order
Use Monitor.TryEnter Try to acquire locks with timeout to avoid blocking forever
Use async primitives Prefer SemaphoreSlim.WaitAsync() instead of traditional lock when mixing with async

Example: Using SemaphoreSlim in Async Code

private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

public async Task UseAsyncResource()
{
    await _semaphore.WaitAsync();
    try
    {
        // access shared resource
    }
    finally
    {
        _semaphore.Release();
    }
}

Summary

Cause of Deadlock Solution
Blocking async code Use await instead of .Result or .Wait()
Synchronous lock ordering Lock resources in a consistent order
Mixed async/sync logic Avoid using Task.Run inside async code if possible
Using UI thread in async Use ConfigureAwait(false) when appropriate
MindStick Training
Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md