Finite Queue Calculator
A queue with no room limit grows without bound as soon as arrivals outpace service. A real one cannot: a phone line has so many slots, a waiting room so many chairs, a buffer so many bytes. What happens instead is that people are turned away, and that changes the question entirely — from how long the queue gets to what fraction of demand you simply lose.
What this generator does
Computes the probability of finding each possible number in the system, from empty to full, then derives the blocking probability, the average number present, the rate actually admitted and the average time each admitted arrival spends there.
How to use this tool
- Set how many fit in the system in total, including the one being served.
- Read the proportion turned away, then the average number present.
- Note that the average never exceeds the capacity, however heavy the load.
- Increase the capacity and watch blocking fall with diminishing returns.
Understanding the controls
- How many fit in total
- Between 1 and 20, counting the one being served as well as those waiting. This is the whole system, not just the waiting room.
- Seed
- Any word reproduces the same arrival and service rates, so a scenario can be set and revisited.
Common use cases
- Sizing a call queue, waiting room or buffer
- Working out how much capacity is needed to hit a blocking target
- Teaching why a bounded queue behaves differently from an unbounded one
- Showing that Little's law needs the admitted rate, not the arrival rate
- Setting the same scenario twice from a seed
How this generator works
The chance of each state is proportional to the load ratio raised to that number, and dividing by the total makes them into probabilities that sum to one — which is checked rather than assumed. The average time uses Little's law with the rate that actually gets in, not the rate that turns up. Using the arrival rate there is the classic mistake, and it overstates the wait by exactly the blocked fraction.
Randomness and fairness
The arrival and service rates are drawn at random to give a scenario; every figure derived from them is deterministic. A seed reproduces the same scenario exactly and is therefore explicitly not cryptographically secure. Without a seed the browser's cryptographically secure generator is used.
For how randomness is produced across the whole site, see how Generate Random works.
Limitations and good to know
- One server, with arrivals and service both memoryless — the standard assumptions, and only ever approximately true.
- Arrivals turned away are lost rather than retrying, which real callers frequently do.
- Steady state: it says nothing about a rush that builds and clears.
- No priority or reneging — everyone waits their turn and nobody gives up.
- Scenarios are not stored between visits; seed one you want again.
Privacy and your data
Every figure is computed in your browser. Nothing about the scenario or your seed is transmitted or stored.
Related generators
- Queue Waiting Time CalculatorClosed-form waiting times for a multi-server queue, with Little's law as the check and no finite answer offered for an unstable one.
- Queue SimulatorSimulate a queue from arrival and service rates and see the waiting times — including why waiting explodes near capacity rather than rising smoothly.
- Branching Process SimulatorPopulation lines that either die out or grow without bound, with the exact extinction probability solved from the process's own equation.
- Shift Coverage GeneratorWorks out which shifts to roster so every hour's demand is met, and shows the paid slack that fixed-length shifts make unavoidable.