Loading
Pick a focused question that fits your time, stack, and interview goal.
16 results across 1 active filter
Page 1 of 1
Uses reduction, thread-local state, atomic scalar updates, or indexed output instead of mutating a shared collection from parallel workers.
Use Channel<T> to coordinate producer/consumer background processing inside a .NET service while respecting backpressure and shutdown.
Choose between ConcurrentDictionary and explicit locks when managing concurrent in-memory data.
Serializes work for the same resource while preserving concurrency across independent keys and managing keyed-lock lifetime safely.
Explain why awaiting while holding synchronization resources can create deadlocks, contention, or stalled workflows.
Diagnoses thread-unsafe scoped dependencies inside parallel execution and redesigns the data boundary without exhausting shared resources.
Chooses between atomic operations and a critical section based on whether one value or a multi-step invariant must change safely.
Design a bounded-concurrency approach for calling an external API safely from .NET code.
Compare lock and SemaphoreSlim for protecting shared state and coordinating async workflows.
Finds circular lock acquisition and replaces timing-dependent nested locking with a stable order or a simpler ownership boundary.
Investigate and fix a race condition caused by shared mutable state in a .NET service.
Uses runtime-supported initialization rather than timing-dependent manual checks and defines failure, retry, and disposal behavior explicitly.
Redesigns read-heavy shared state so readers observe a complete version without coordinating every access through a lock.
Use SemaphoreSlim to bound concurrent asynchronous work without blocking threads unnecessarily.
Evaluates whether read-heavy access justifies a reader/writer lock instead of a simpler lock or immutable snapshot.
Separates memory visibility and ordering from atomic multi-step updates, avoiding volatile as a substitute for real synchronization.