I'm comparing two common ways to control concurrency in async Python. With a semaphore, I can let tasks acquire a limited number of slots before calling something like `do_work()`. Alternatively, I can put jobs into an `asyncio.Queue` and run a fixed number of worker tasks.
How do you decide between these approaches in real applications? Are there important differences in backpressure, cancellation, fairness, task lifetime, failure handling, or overall complexity? I'm especially interested in cases where a semaphore is clearly the better abstraction than a worker queue, and vice versa.
3 Answers
A semaphore is usually the simplest choice when the work already exists as a manageable batch and you only need to cap concurrent operations. Each task can acquire a slot, perform its operation, and release the slot automatically with `async with sem:`. This works well for things like limiting simultaneous API requests or database calls without introducing worker management, shutdown signals, or queue bookkeeping.
Use a queue when you have a producer-consumer design: work arrives over time, the total amount may be unknown, or several pipeline stages need to pass jobs around. A bounded queue also provides real backpressure—producers have to wait when the queue is full. Fixed workers make task lifetime predictable and give you a natural place to handle retries, failures, and graceful shutdown.
The two techniques can enforce a similar concurrency limit, but cancellation and lifecycle management differ. With a semaphore, every submitted item is typically its own task, so cancelling a task can be straightforward—but a huge `gather()` may leave thousands of waiting tasks to cancel. With workers, you only cancel the worker tasks, while pending jobs remain in the queue; however, stopping cleanly may require draining the queue, waiting for `queue.join()`, or using sentinel values. Pick the model that matches the ownership of the work rather than treating them as interchangeable primitives.
That distinction matters even more for very large inputs. Creating one task per item and having most of them wait on a semaphore can consume a lot of memory. A queue with a fixed number of workers keeps only a small number of tasks alive regardless of how many jobs remain.