What is a race condition? Give examples in .NET, including async and database races, and explain how you find and fix them.

1. Why races hide

• The window between read and write can be nanoseconds; it widens only under load, with more cores, GC pauses or preemption.
• Debuggers and logging change timing, so the bug disappears when you look (a "Heisenbug").
• Weaker memory models (Arm64) expose ordering races that x64 hides.
• Dev and CI machines have fewer cores and less contention than production.

2. Designing races out

3. ConcurrentDictionary caveats

// Factory can run more than once under contention; only one result is stored.
var value = cache.GetOrAdd(key, k => ExpensiveLoad(k));

// Run the factory at most once per key:
var lazy = cache2.GetOrAdd(key, k => new Lazy<Data>(() => ExpensiveLoad(k), LazyThreadSafetyMode.ExecutionAndPublication));
var data = lazy.Value;

// Compound operations are still races:
if (cache.TryGetValue(k, out var v)) cache[k] = v + 1;           // RACE
cache.AddOrUpdate(k, 1, (_, old) => old + 1);                     // OK (update delegate may be retried)

4. EF Core optimistic concurrency with retry

for (int attempt = 0; attempt < 3; attempt++)
{
    var product = await db.Products.SingleAsync(p => p.Id == id, ct);
    if (product.Stock < qty) return Results.Conflict("Out of stock");
    product.Stock -= qty;
    try
    {
        await db.SaveChangesAsync(ct);    // WHERE Id = @id AND RowVersion = @original
        return Results.Ok();
    }
    catch (DbUpdateConcurrencyException)
    {
        db.ChangeTracker.Clear();         // reload and retry
    }
}
return Results.Conflict("Please retry");

For simple counters, the atomic update is simpler and has no retries:

int rows = await db.Products
    .Where(p => p.Id == id && p.Stock >= qty)
    .ExecuteUpdateAsync(s => s.SetProperty(p => p.Stock, p => p.Stock - qty), ct);
if (rows == 0) return Results.Conflict("Out of stock");

5. A stress test that finds races

[Fact]
public async Task Only_one_booking_wins()
{
    var tasks = Enumerable.Range(0, 100).Select(c => client.PostAsync($"/seats/42/book?customer={c}", null));
    var responses = await Task.WhenAll(tasks);
    Assert.Equal(1, responses.Count(r => r.StatusCode == HttpStatusCode.OK));
    Assert.Equal(99, responses.Count(r => r.StatusCode == HttpStatusCode.Conflict));
}

6. Version notes

7. Try it yourself

1. Run the code example: 10 loads for 10 keys despite 1,000 concurrent calls.
2. Uncomment the unsafe Dictionary version and run it repeatedly; watch for exceptions or wrong counts.
3. Add 10,000 items to a shared List<int> from 8 tasks and print Count.
4. In EF Core, add [Timestamp] and save the same entity from two DbContexts; catch DbUpdateConcurrencyException.
5. Write the 100-client seat test against a version without the constraint, then with it.
6. Simulate a double-click by calling an async save twice without awaiting the first, and add a re-entry guard.

using System.Collections.Concurrent;

// 1. Check-then-act race and its fix.
var unsafeCache = new Dictionary<string, int>();
var safeCache = new ConcurrentDictionary<string, Lazy<int>>();
int loads = 0;

Parallel.For(0, 1_000, i =>
{
    string key = $"k{i % 10}";
    // Race: two threads can both miss and both load (and corrupt the Dictionary).
    // if (!unsafeCache.ContainsKey(key)) unsafeCache[key] = Load(key);

    // Safe: one Lazy per key, so Load runs once per key even under contention.
    _ = safeCache.GetOrAdd(key, k => new Lazy<int>(() => Load(k))).Value;
});
Console.WriteLine($"Loads: {loads}"); // 10

int Load(string key)
{
    Interlocked.Increment(ref loads);
    return key.Length;
}

// 2. Database lost update: atomic statement instead of read-modify-write (EF Core 7+).
// int rows = await db.Seats
//     .Where(s => s.Id == seatId && s.HolderId == null)
//     .ExecuteUpdateAsync(s => s.SetProperty(x => x.HolderId, customerId), ct);
// if (rows == 0) return Results.Conflict("Seat already taken");

// 3. Optimistic concurrency token on an entity.
public sealed class Seat
{
    public int Id { get; set; }
    public int? HolderId { get; set; }
    [System.ComponentModel.DataAnnotations.Timestamp]
    public byte[] RowVersion { get; set; } = [];
}