What is a deadlock and how can you prevent it in .NET?

Question

Ravi Vishwakarma · Answer

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 Taskandlt;stringandgt; 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 Taskandlt;stringandgt; 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:
Thread 1 holds lockA, waits for lockBThread 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
and

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

interview

What is a deadlock and how can you prevent it in .NET?

Ravi Vishwakarma

Can you answer this question?

1 Answers

What is a Deadlock in .NET?

Common Example: Async Deadlock

Problem Code

What Happens

Fix: Use `await` all the way

Deadlock in Locking Code (Multi-threaded Deadlock)

Example:

Deadlock Risk:

Prevention Strategies

For Async Deadlocks:

For Thread Deadlocks:

Example: Using `SemaphoreSlim` in Async Code

Summary

Liked By

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

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