Loading
Pick a focused question that fits your time, stack, and interview goal.
12 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.
Sets concurrency from the constrained resource and verifies throughput, latency, and downstream safety instead of maximizing active work.
Serializes work for the same resource while preserving concurrency across independent keys and managing keyed-lock lifetime safely.
Decide how to handle CPU-heavy work in an API without damaging request throughput or making the system unreliable.
Diagnoses thread-unsafe scoped dependencies inside parallel execution and redesigns the data boundary without exhausting shared resources.
Defines what happens when several operations fail, cancellation arrives, or only part of a parallel batch completes, without orphaning work or hiding errors.
Design a bounded-concurrency approach for calling an external API safely from .NET code.
Proves parallel speedup against a sequential baseline while accounting for overhead, saturation, tail latency, resource contention, and downstream impact.
Compare Parallel.ForEachAsync and Task.WhenAll for processing collections with async work and controlled concurrency.
Chooses a parallel API based on whether the workload is a data query or an imperative loop and keeps CPU work pure, bounded, and measurable.
Explain when Task.Run is useful, when async/await is enough, and why Task.Run is usually wrong for I/O in ASP.NET Core.
Use SemaphoreSlim to bound concurrent asynchronous work without blocking threads unnecessarily.