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

forum

Ask Question

1 Answers

Anubhav Sharma
Anubhav Sharma 13 Jun 2025
Report Abuse

A deadlock is a situation where two or more threads (or tasks) are waiting for each other to release resources, and none of them ever proceed — resulting in a permanent blocking cycle.

In .NET, deadlocks can occur in:

  • Multithreading (e.g., lock)
  • Asynchronous code (async/await)
  • Database transactions

Threading Deadlock Example

object lockA = new object();
object lockB = new object();

void Thread1()
{
    lock (lockA)
    {
        Thread.Sleep(100); // Give Thread2 a chance to lock B
        lock (lockB)
        {
            // do something
        }
    }
}

void Thread2()
{
    lock (lockB)
    {
        Thread.Sleep(100);
        lock (lockA) // Deadlock: Thread1 holds A, waits for B; Thread2 holds B, waits for A
        {
            // do something
        }
    }
}

Deadlock in Async/Await

public string GetData()
{
    return GetDataAsync().Result; // blocks UI thread
}

public async Task<string> GetDataAsync()
{
    await Task.Delay(1000); // Tries to resume on captured (blocked) UI thread → deadlock
    return "done";
}

This causes a deadlock especially in UI apps like WinForms/WPF.

How to Prevent Deadlocks

1. Always Acquire Locks in the Same Order

Avoid circular waits.

lock (lockA)
{
    lock (lockB)
    {
        // Safe if always A → B
    }
}

2. Avoid Synchronous Blocking on Async Code

Prefer await over .Result or .Wait()

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

// Good
string result = await GetDataAsync();

3. Use Timeout with Locks

bool lockTaken = Monitor.TryEnter(lockA, TimeSpan.FromSeconds(2));
if (lockTaken)
{
    try
    {
        // do work
    }
    finally
    {
        Monitor.Exit(lockA);
    }
}
else
{
    // handle lock timeout
}

4. Use ConfigureAwait(false) in Library Code

Prevents deadlocks by not capturing the synchronization context:

await Task.Delay(1000).ConfigureAwait(false);

5. Use SemaphoreSlim Instead of lock for Async

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

public async Task SafeMethodAsync()
{
    await _semaphore.WaitAsync();
    try
    {
        // thread-safe async logic
    }
    finally
    {
        _semaphore.Release();
    }
}

Summary

Aspect Details
What is Deadlock? Two or more threads/tasks waiting indefinitely for each other
Causes Improper lock order, blocking async code, nested transactions
Prevention Tips Lock ordering, avoid .Result, use timeouts, prefer await, use ConfigureAwait(false)
advertising
Markdown for AI

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

Open .md