Atendimento UtiliBox

Abrir ticket de suporte

Descreva o que precisa. O chamado ficará registrado e a equipe receberá uma notificação por e-mail.

Teoria das Filas

O simulador gratuito mais completo do mercado: 5 modelos analíticos (M/M/1, M/M/c, Erlang-B/C), Simulação de Eventos Discretos (DES), NHPP, filas com prioridade, redes de filas e animação em tempo real — direto no navegador, sem instalação.

Simulador de filas
M/M/c

Modelo e parâmetros

CV = 1.00

Teoria das Filas: Guia Completo com Exemplos Práticos

A Teoria das Filas (Queueing Theory) é o ramo da matemática aplicada que modela sistemas onde entidades — clientes, pacientes, pacotes de dados, peças industriais — chegam, aguardam quando todos os servidores estão ocupados e depois são atendidas. Criada em 1909 pelo engenheiro dinamarquês Agner Krarup Erlang para dimensionar as centrais telefônicas de Copenhagen, tornou-se em um século a base de decisões em:

  • Engenharia de produção: balanceamento de linhas, dimensionamento de docas, gargalos industriais
  • Saúde: capacidade de UTI, triagem hospitalar, filas de consulta
  • Tecnologia: servidores web, bancos de dados, gateways de API, impressoras de rede
  • Telecom: ramais PABX, call centers, buffers de redes
  • Varejo e logística: check-in de aeroportos, caixas de supermercado, pedágios, postos de gasolina

Softwares como Arena (Rockwell Automation), Simul8 e AnyLogic usam simulação de eventos discretos (DES) para os casos mais complexos. Para a grande maioria dos problemas reais, porém, as fórmulas analíticas desta ferramenta entregam resultados exatos — e em milissegundos.


Trilha de estudo

Siga os blocos na ordem: cada um usa o anterior. Os quadros Em resumo no início de cada modelo servem para revisão rápida; nos exercícios, tente resolver antes de abrir a resolução.

1 · Fundamentos

2 · Modelos analíticos

3 · Dos dados à decisão

4 · Recursos avançados do simulador

5 · Prática

Leitura complementar

Resumo em 1 minuto

  • λ = chegadas por unidade de tempo · μ = atendimentos por servidor · c = servidores · ρ = λ/(c·μ) = fração do tempo em que os servidores estão ocupados.
  • Com ρ ≥ 1 a fila cresce sem parar (sistema instável) — exceto quando há capacidade limitada (M/M/1/K) ou perda (Erlang-B).
  • A espera explode perto de ρ = 1: no M/M/1, WqW_q vale ρ/(1−ρ)\rho/(1-\rho) tempos de atendimento — 1× com 50% de ocupação, 4× com 80%, 9× com 90%.
  • Variabilidade custa espera: tempo de atendimento fixo (CV = 0) gera metade da fila do exponencial (CV = 1).
  • Uma fila única para c servidores espera menos do que c filas separadas com a mesma capacidade.
  • Lei de Little: L=λWL = \lambda W vale para qualquer sistema estável — medindo duas grandezas, você obtém a terceira.

Cola de fórmulas

ModeloUse quandoFórmula-chaveEstável se
M/M/11 servidor, chegadas e atendimentos aleatóriosWq=λμ(μ−λ)W_q=\dfrac{\lambda}{\mu(\mu-\lambda)}λ<μ\lambda<\mu
M/M/cc servidores, fila única (Erlang-C)Wq=C(c,a)cμ−λW_q=\dfrac{C(c,a)}{c\mu-\lambda}λ<cμ\lambda<c\mu
M/D/1atendimento de tempo fixoLq=ρ22(1−ρ)L_q=\dfrac{\rho^2}{2(1-\rho)}ρ<1\rho<1
M/G/1atendimento com qualquer distribuição (CV conhecido)Lq=ρ2(1+CV2)2(1−ρ)L_q=\dfrac{\rho^2(1+CV^2)}{2(1-\rho)}ρ<1\rho<1
M/M/1/Kcapacidade máxima K (excesso é recusado)PK=(1−ρ)ρK1−ρK+1P_K=\dfrac{(1-\rho)\rho^K}{1-\rho^{K+1}}sempre
M/M/c/csem fila: quem não acha servidor livre é perdido (Erlang-B)B(c,a)=a B(c−1,a)c+a B(c−1,a)B(c,a)=\dfrac{a\,B(c-1,a)}{c+a\,B(c-1,a)}sempre
Littlequalquer sistema estávelL=λWL=\lambda W · Lq=λWqL_q=\lambda W_q—

↑ Voltar à trilha de estudo


Notação de Kendall — como descrever qualquer fila

Todo sistema de filas é descrito pela notação compacta A/S/c/K:

PosiçãoO que representaSímbolos comuns
AProcesso de chegadaM (Poisson/aleatório), D (fixo/determinístico)
SDistribuição do tempo de serviçoM (exponencial), D (determinístico/fixo)
cNúmero de servidores em paralelo1, 2, 3…
KCapacidade máxima do sistemanúmero ou ∞ (omitido = ilimitado)

Exemplos de leitura da notação

Sistema realNotaçãoLeitura
Guichê de triagem hospitalarM/M/1Chegadas aleatórias, serviço variável, 1 enfermeiro
Agência bancária com 2 caixasM/M/2Chegadas aleatórias, serviço variável, 2 caixas paralelos
Linha de montagem cadenciadaM/D/1Chegadas aleatórias, tempo de ciclo fixo, 1 estação
Estacionamento com 15 vagasM/M/1/15Chegadas aleatórias, 1 “servidor”, capacidade máxima 15
PABX com 4 ramaisM/M/4/4Erlang-B: 4 servidores, sem fila, excesso é perdido

Como estender a notação — A/S/c/K/N/D completo

A notação completa é A/S/c/K/N/D:

PosiçãoO que representaPadrão quando omitido
AProcesso de chegada— (obrigatório)
SDistribuição de serviço— (obrigatório)
cServidores paralelos— (obrigatório)
KCapacidade máxima do sistema∞ (fila ilimitada)
NTamanho da população de origem∞ (infinita)
DDisciplina da filaFIFO

Quando K = c (capacidade = número de servidores), chegadas em excesso são bloqueadas imediatamente sem formar fila — é o modelo Erlang-B (M/M/c/c).

Populações finitas (N finito): em sistemas onde há N máquinas e c técnicos de manutenção, ao parar uma máquina ela sai da “população geradora de chamados”. O modelo M/M/c//N (máquina de reparo de Engset) captura esse efeito — a taxa de chegada efetiva cai à medida que mais máquinas ficam paradas. Para esses casos, use a simulação DES da ferramenta.

Processos de chegada além do Poisson

O processo de Poisson (M) implica: (a) chegadas independentes entre si, (b) taxa constante λ no tempo, (c) no máximo uma chegada por instante infinitesimal. É uma excelente aproximação quando há muitas fontes pequenas e independentes — clientes distribuídos por uma cidade, requisições HTTP de milhares de usuários.

Quando o Poisson não se aplica:

SituaçãoProcesso mais adequadoImpacto
Chegadas em lotes (grupos, famílias, ônibus de turistas)M[X]/M/c — batch arrivalsLq pode ser 2–5× maior
λ varia ao longo do diaNHPP (configure com ⏱ λ variável)Pico até 10× o vale
Fontes em número finito (N máquinas)Engset / M/M/c//Nλ efetivo decresce com ocupação
Chegadas correlacionadas (rajadas de rede, burst traffic)MMPP (Markov-Modulated Poisson)Filas muito maiores que Poisson
Chegadas periódicas (ciclos de produção, takt time)D/M/c (chegadas determinísticas)Fila menor que Poisson

Para fins práticos, o Poisson é robusto: erros de modelagem tipicamente causam desvios menores do que a própria incerteza na estimativa de λ e μ a partir de dados reais.

↑ Voltar à trilha de estudo


Os três parâmetros fundamentais

λ — Taxa de chegada

Número médio de entidades que chegam por unidade de tempo. É sempre obtido de observação real ou histórico.

CenárioλUnidade
Agência bancária (horário de pico)20clientes/hora
Servidor web em produção120requisições/segundo
Pronto-socorro15pacientes/hora
Pedágio (por pista)120carros/hora
Check-in de aeroporto180passageiros/hora

Como medir λ: conte o número de chegadas durante um período representativo (e.g., 1 hora) e divida pelo tempo. Repita em dias e horários diferentes para capturar a variabilidade.

μ — Taxa de serviço de um servidor

Número médio de atendimentos que um único servidor realiza por unidade de tempo. O tempo médio de atendimento é 1/μ.

CenárioμTempo médio de atendimento
Caixa de agência bancária15 /h4 minutos
Médico em consultório4 /h15 minutos
Farmácia hospitalar (dispensação)80 /h45 segundos
Técnico de manutenção2 /h30 minutos
Worker de banco de dados250 /s4 ms

Dica: se o tempo de serviço for altamente variável (CV > 1), prefira o modelo M/M/c. Se for praticamente constante (CV < 0,15), use M/D/1 ou M/D/c para resultados mais precisos.

ρ — Utilização por servidor

ρ=λc⋅μ\rho = \frac{\lambda}{c \cdot \mu}

ρ representa a fração do tempo em que cada servidor está ocupado. Para sistemas estáveis: ρ < 1. Quando ρ ≥ 1, a fila cresce sem limite.

O efeito exponencial da utilização

A relação entre ρ e o tempo de espera não é linear — é explosiva. No modelo M/M/1:

ρWq (múltiplos de 1/μ)
50%1×
70%2,3×
80%4×
90%9×
95%19×
99%99×

Passar de 80% para 90% de utilização mais que dobra o tempo de espera.

A zona operacional ideal e o custo da ociosidade

Existe uma tensão fundamental na gestão de capacidade:

  • Muita folga (ρ baixo): servidores ociosos, custo fixo elevado, subutilização de investimento
  • Pouca folga (ρ alto): filas longas, clientes insatisfeitos, risco de colapso em picos transientes

A zona de operação recomendada depende do custo relativo de espera vs. servidor ocioso:

Setorρ típico operacionalJustificativa
UTI / emergência hospitalar60–70%O custo de não ter leito disponível é vida humana
Servidor web crítico60–75%Picos súbitos são comuns; latência mata conversão
Call center premium (SLA rígido)70–80%SLA de 80% atendidos em 20 s
Agência bancária75–85%Cliente aguarda até ~5 min sem reclamar
Linha de produção80–90%Demanda mais previsível, estoque amortece picos
Pedágio / check-in85–92%Picos são conhecidos e planejados
Call center de baixo custo88–93%SLA mais flexível, custo por atendente é dominante

A fórmula para o custo total por unidade de tempo equilibra os dois lados:

Custo total=c⋅hs+λ⋅Wq⋅he\text{Custo total} = c \cdot h_s + \lambda \cdot W_q \cdot h_e

onde hsh_s = custo horário de um servidor (salário + encargos + infra) e heh_e = custo horário de um cliente esperando (produtividade perdida, churn, penalidade contratual). O número ótimo de servidores minimiza essa função.

Como estimar ρ antes de ter dados precisos

Se você ainda não mediu λ e μ, use estas heurísticas para estimar rapidamente:

  • λ (chegadas): divida o volume total do período pelo tempo do período. Para horário de pico, use apenas os dados de pico.
  • μ (serviço): cronometre 20–30 atendimentos em condições normais. Use a média como 1/μ. Calcule o CV — se > 0,5, o M/M/c é mais adequado que o M/D/1.
  • ρ preliminar: use λ/(c·μ). Se der > 0,95, o sistema está em risco independentemente do modelo escolhido.

↑ Voltar à trilha de estudo


Lei de Little — a ligação universal

📌 Em resumo — Use quando: quiser obter L, λ ou W a partir das outras duas. · Fórmula-chave: L=λWL=\lambda W · Armadilha: use as mesmas unidades e um período estável (sem misturar pico e vale).

Válida para qualquer sistema estável, independente do modelo ou distribuição:

L=λ⋅WLq=λ⋅WqL = \lambda \cdot W \qquad L_q = \lambda \cdot W_q

Exemplo prático: Em uma linha de montagem, há em média 8 peças no sistema. O tempo de ciclo total (do início ao fim) é 12 minutos. Taxa de saída = L/W = 8/12 = 0,667 peças/min = 40 peças/hora.

A Lei de Little permite medir qualquer grandeza (L, W ou λ) a partir das outras duas — sem depender de modelo matemático.

Aplicações práticas da Lei de Little

1. Medir throughput real de uma fábrica

Há 40 ordens em andamento (L = 40). O lead time médio é 5 dias (W = 5). Portanto λ = L/W = 8 ordens concluídas por dia — mesmo sem medir λ diretamente.

2. Estimar WIP necessário para atingir um throughput

Uma linha deve processar 200 peças/dia (λ = 200). O tempo de ciclo (W) é 4 horas = 0,5 dia. Logo o WIP médio deve ser L = 200 × 0,5 = 100 peças em processo simultâneo.

3. Medir o lead time de uma pipeline de software (DevOps)

Há 15 cards ativos no Kanban (L = 15). A equipe fecha 3 cards por dia (λ = 3). Lead time médio = L/λ = 5 dias — métrica central do DORA e do Fluxo.

4. Dimensionamento de inventário em trânsito

Empresa exporta 500 contêineres/mês. Tempo médio de trânsito: 18 dias = 0,6 mês. Inventário médio em trânsito = 500 × 0,6 = 300 contêineres imobilizados.

5. Filas hospitalares — relação entre espera e ocupação

UTI com 10 leitos (c = 10). Taxa de internação: 2/dia. Permanência média: 4 dias. L = 2 × 4 = 8 leitos ocupados em média → ρ = 80%.

Teorema de Jackson — redes de filas

Para redes de filas com servidores M/M/c e roteamento probabilístico (Jackson networks), o teorema de Jackson afirma que cada nó se comporta como uma fila M/M/c independente em regime estacionário, com λ efetivo calculado pela equação de equilíbrio de fluxo:

λj=Λj+∑iλi⋅rij\lambda_j = \Lambda_j + \sum_{i} \lambda_i \cdot r_{ij}

onde Λj\Lambda_j é a taxa de chegada externa ao nó j e rijr_{ij} é a fração de entidades que vão do nó i ao nó j.

Isso permite calcular Wq, Lq e ρ de cada etapa independentemente usando as fórmulas M/M/c — e somar os Wq para obter o tempo total em uma rede em série. A ferramenta de rede de filas desta calculadora usa exatamente este princípio.

↑ Voltar à trilha de estudo


Modelo M/M/1 — o caso fundamental

📌 Em resumo — Use quando: 1 servidor, chegadas aleatórias e tempo de atendimento variável. · Fórmula-chave: Wq=λ/[μ(μ−λ)]W_q=\lambda/[\mu(\mu-\lambda)] · Armadilha: perto de ρ = 1 a espera dispara — com 90% de ocupação, a espera média já é 9× o tempo de atendimento.

Quando usar: sistema com um único servidor, chegadas aleatórias e tempo de serviço variável.

Fórmulas

ρ=λμP0=1−ρ\rho = \frac{\lambda}{\mu} \qquad P_0 = 1 - \rho

L=ρ1−ρLq=ρ21−ρL = \frac{\rho}{1-\rho} \qquad L_q = \frac{\rho^2}{1-\rho}

W=1μ−λWq=λμ(μ−λ)W = \frac{1}{\mu - \lambda} \qquad W_q = \frac{\lambda}{\mu(\mu-\lambda)}

Exemplo: Pronto-socorro (triagem)

15 pacientes chegam por hora a um posto de triagem com 1 enfermeiro. Tempo médio de triagem: 3 minutos (μ = 20/h).

ρ=1520=0,75Wq=1520×(20−15)=0,15 h=9 minutos\rho = \frac{15}{20} = 0{,}75 \qquad W_q = \frac{15}{20 \times (20-15)} = 0{,}15\text{ h} = 9 \text{ minutos}

Lq=0,7521−0,75=2,25 pacientes aguardandoL_q = \frac{0{,}75^2}{1-0{,}75} = 2{,}25 \text{ pacientes aguardando}

O enfermeiro está ocupado 75% do tempo. Se o fluxo subir para 18/h (ρ = 0,90), Wq salta para 27 minutos. Com 2 enfermeiros (M/M/2), Wq cai para menos de 2 minutos.


Exemplo: Servidor web (thread única)

120 req/s, processamento médio de 6 ms (μ = 167 req/s).

ρ=120167≈0,719Wq≈15,3 ms de filaW≈21,3 ms total\rho = \frac{120}{167} \approx 0{,}719 \qquad W_q \approx 15{,}3 \text{ ms de fila} \qquad W \approx 21{,}3 \text{ ms total}

Para latências abaixo de 10 ms totais, é necessário múltiplas threads (M/M/c). Com 2 threads, Wq cai para ~0,9 ms.


Exemplo: Portaria de condomínio

8 visitantes chegam por hora a uma portaria com 1 porteiro. Cadastro demora em média 5 minutos (μ = 12/h).

ρ=812=0,667Wq=812(12−8)=848≈0,167 h=10 min\rho = \frac{8}{12} = 0{,}667 \qquad W_q = \frac{8}{12(12-8)} = \frac{8}{48} \approx 0{,}167\text{ h} = 10 \text{ min}

Lq=0,66720,333=1,33 visitantes aguardando em meˊdiaL_q = \frac{0{,}667^2}{0{,}333} = 1{,}33 \text{ visitantes aguardando em média}

Se o porteiro agilizar o cadastro para 3 minutos (μ = 20/h, ρ = 40%), Wq cai para 2 minutos — sem contratar ninguém.

Exemplo: Médico em consultório

3 pacientes chegam por hora. Consulta dura em média 15 min (μ = 4/h).

ρ=34=0,75Wq=34(4−3)=0,75 h=45 min de espera\rho = \frac{3}{4} = 0{,}75 \qquad W_q = \frac{3}{4(4-3)} = 0{,}75\text{ h} = 45 \text{ min de espera}

Com agenda (chegadas mais regulares que o Poisson), a espera cai, porque a variabilidade das chegadas também alimenta a fila. Com sistema de agendamento online que elimina no-shows, λ efetivo cai para ~2,5/h (ρ = 0,625 → Wq ≈ 25 min) e a agenda passa a ser cumprida.

Exemplo: Worker de processamento de imagens (microserviço)

Pipeline de IA recebe 5 imagens/segundo. O modelo de inferência demora em média 150 ms (μ = 6,67/s).

ρ=56,67=0,75Wq=56,67(6,67−5)≈450 ms de fila\rho = \frac{5}{6{,}67} = 0{,}75 \qquad W_q = \frac{5}{6{,}67(6{,}67-5)} \approx 450 \text{ ms de fila}

Wtotal=450+150=600 ms— acima do limite de 500 ms exigido pelo SLAW_{\text{total}} = 450 + 150 = 600 \text{ ms} \quad \text{— acima do limite de 500 ms exigido pelo SLA}

Adicionando uma 2ª GPU (M/M/2, ρ = 0,375), Wq cai para ~25 ms (W ≈ 175 ms). O custo da GPU se paga em evitar violações do SLA.

Interpretação conjunta das métricas M/M/1

MétricaFórmulaInterpretação operacional
ρλ/μFração do tempo em que o servidor está ocupado
P₀1 − ρProbabilidade de encontrar o sistema vazio (sem espera)
Lρ/(1−ρ)Número médio no sistema (fila + atendimento)
Lqρ²/(1−ρ)Número médio aguardando (não em atendimento)
W1/(μ−λ)Tempo médio total no sistema (espera + serviço)
Wqλ/[μ(μ−λ)]Tempo médio apenas esperando na fila

A Lei de Little conecta tudo: L = λW e Lq = λWq. Se você medir qualquer dois, calcula o terceiro.

↑ Voltar à trilha de estudo


Modelo M/M/c — múltiplos servidores paralelos (Erlang-C)

📌 Em resumo — Use quando: c servidores iguais atendem a mesma fila (call center, caixas, guichês). · Fórmula-chave: Erlang-C, Wq=C(c,a)/(cμ−λ)W_q=C(c,a)/(c\mu-\lambda) · Armadilha: a condição é λ<cμ\lambda<c\mu; e separar uma fila por servidor piora a espera.

Quando usar: vários servidores idênticos atendem a mesma fila — call centers, caixas de banco, guichês de aeroporto, bancos de threads.

Fórmula de Erlang-C

C(c,a)=acc!⋅cc−a∑n=0c−1ann!+acc!⋅cc−aC(c, a) = \frac{\dfrac{a^c}{c!} \cdot \dfrac{c}{c-a}}{\displaystyle\sum_{n=0}^{c-1} \frac{a^n}{n!} + \dfrac{a^c}{c!} \cdot \dfrac{c}{c-a}}

onde a=λ/μa = \lambda/\mu é o tráfego em Erlangs e ρ=a/c\rho = a/c.

Lq=C(c,a)⋅ρ1−ρWq=LqλW=Wq+1μL=λWL_q = C(c,a) \cdot \frac{\rho}{1-\rho} \qquad W_q = \frac{L_q}{\lambda} \qquad W = W_q + \frac{1}{\mu} \qquad L = \lambda W

Exemplo: Agência bancária com 2 caixas

20 clientes/hora, cada caixa atende 15 clientes/hora. Modelo M/M/2.

a=2015=1,33 Erlangsρ=1,332=0,667a = \frac{20}{15} = 1{,}33\text{ Erlangs} \qquad \rho = \frac{1{,}33}{2} = 0{,}667

Erlang-C → P(esperar) ≈ 53,3% → Wq ≈ 3,2 minutos

Com apenas 1 caixa (ρ = 1,33): sistema instável — fila infinita. O segundo caixa é essencial. O terceiro reduziria Wq para ~26 segundos.


Exemplo: Call center — dimensionamento por SLA

90 ligações/hora, atendimento de 4 minutos (μ = 15/h). SLA: 80% das ligações atendidas em ≤ 20 segundos.

Atendentes (c)ρP(esperar)P(Wq ≤ 20s)
785,7%61,4%~44% ❌
875,0%35,7%~70% ❌
966,7%19,6%~85% ✅
1060,0%10,1%~93%

Com 9 atendentes o SLA é atingido (85% das ligações atendidas em até 20 s). Na prática, recomenda-se 10 para absorver ausências e picos.


Exemplo: Check-in de aeroporto

180 passageiros/hora, atendimento de 2 minutos (μ = 30/h), 8 guichês.

a=6 Erlangsρ=0,75Wq≈22 sa = 6\text{ Erlangs} \qquad \rho = 0{,}75 \qquad W_q \approx 22 \text{ s}

Se um guichê fechar (c=7, ρ = 85,7%), Wq sobe para ~1,2 min — mais que o triplo, e a fila cresce rápido em dias de pico.


Exemplo: Banco de dados — dimensionamento do pool de workers

200 queries/s, execução média 4 ms (μ = 250/s). Pool de 4 workers.

a=200250=0,8 Erlangsρ=0,84=0,20a = \frac{200}{250} = 0{,}8\text{ Erlangs} \qquad \rho = \frac{0{,}8}{4} = 0{,}20

Com ρ = 20%, o sistema está muito folgado. Wq ≈ 0,01 ms. Com 2 workers (ρ = 40%), Wq ≈ 0,8 ms — ainda excelente. O pool de 4 garante headroom para picos de até 480 queries/s sem degradação.


Exemplo: Posto de gasolina

20 carros/hora chegam, abastecimento médio de 4 minutos (μ = 15/h), 3 bombas.

a=2015=1,33 Erlangsρ=1,333=0,444a = \frac{20}{15} = 1{,}33\text{ Erlangs} \qquad \rho = \frac{1{,}33}{3} = 0{,}444

P(esperar) ≈ 18%. Wq ≈ 26 segundos. Sistema bem dimensionado. Com 2 bombas (ρ = 0,667), Wq já subiria para ~3,2 min.


Exemplo: Equipe de manutenção

3 chamados por hora chegam a uma equipe de 2 técnicos. Cada reparo dura 30 min em média (μ = 2/h).

a=32=1,5 Erlangsρ=1,52=0,75a = \frac{3}{2} = 1{,}5\text{ Erlangs} \qquad \rho = \frac{1{,}5}{2} = 0{,}75

P(esperar) ≈ 64%. Wq ≈ 39 minutos de espera antes do técnico chegar. O custo de máquina parada durante esse tempo justifica a análise de adicionar um 3º técnico (que reduziria Wq para ~5 min).

Exemplo: Atendimento de suporte de TI (help desk)

12 tickets chegam por hora. Resolução média: 20 min (μ = 3/h). Equipe de 5 analistas.

a=123=4 Erlangsρ=45=0,80a = \frac{12}{3} = 4\text{ Erlangs} \qquad \rho = \frac{4}{5} = 0{,}80

Erlang-C: C(5, 4) ≈ 55,4% → Wq ≈ 11,1 min. Com 6 analistas (ρ = 0,667): Wq ≈ 2,9 min. O 6º analista custa menos que o impacto de 8 min adicionais de espera para 12 tickets/hora.

Exemplo: Farmácia de hospital público (dispensação de medicamentos)

60 receitas chegam por hora, 4 farmacêuticos, cada um atende 20 receitas/h.

a=6020=3 Erlangsρ=34=0,75a = \frac{60}{20} = 3\text{ Erlangs} \qquad \rho = \frac{3}{4} = 0{,}75

C(4, 3) ≈ 50,9% → Wq ≈ 1,5 minuto — aceitável para uma farmácia hospitalar. No pico de entrega de alta (λ = 90/h): ρ = 1,125 → instável → necessário 5º farmacêutico ou triagem de urgência.

Exemplo: Impressora de rede compartilhada (servidor de impressão)

8 usuários enviam trabalhos a uma fila de impressão. Em média, 3 trabalhos/min chegam, impressão leva 15 s (μ = 4/min), 1 impressora.

a=34=0,75 Erlangρ=0,75Wq≈45 sa = \frac{3}{4} = 0{,}75\text{ Erlang} \qquad \rho = 0{,}75 \qquad W_q \approx 45\text{ s}

Com 2 impressoras (M/M/2, ρ = 0,375): Wq ≈ 2,5 s. Para uma equipe que imprime relatórios críticos, a segunda impressora elimina frustração.

Dimensionamento ótimo com tabela comparativa

A tabela de servidores exibida abaixo do resultado M/M/c mostra automaticamente c−1, c, c+1, c+2:

cρC(c,a)WqLCusto/hora
31,00instável∞∞3 × hsh_s
40,7550,9%92 s4,534 × hsh_s
50,6023,6%21 s3,355 × hsh_s
60,509,9%6 s3,106 × hsh_s

A decisão entre c=4 e c=5 exige comparar o custo de 1 farmacêutico adicional com o custo de ~71 s extras de espera para 60 receitas/hora.

↑ Voltar à trilha de estudo


Modelo M/D/1 — serviço de tempo fixo (Pollaczek-Khinchine)

📌 Em resumo — Use quando: o atendimento tem tempo fixo (linha cadenciada, pedágio eletrônico). · Fórmula-chave: Lq=ρ2/[2(1−ρ)]L_q=\rho^2/[2(1-\rho)] — metade da fila do M/M/1. · Armadilha: só vale se o tempo for de fato quase constante (CV < 0,15).

Quando usar: o tempo de atendimento é constante — linha de produção cadenciada, impressora de rede, farmácia com protocolo padronizado, pedágio eletrônico.

Fórmula P-K para variância zero

LqM/D/1=ρ22(1−ρ)=12⋅LqM/M/1L_q^{M/D/1} = \frac{\rho^2}{2(1-\rho)} = \frac{1}{2} \cdot L_q^{M/M/1}

Conclusão chave: com tempo fixo, a fila é exatamente metade do caso M/M/1 equivalente.

Exemplo: Farmácia hospitalar

40 pedidos/hora chegam. Dispensação padronizada em 45 segundos fixos (μ = 80/h).

ρ=4080=0,50\rho = \frac{40}{80} = 0{,}50

WqM/D/1=0,5022(1−0,50)×40≈22 segundosW_q^{M/D/1} = \frac{0{,}50^2}{2(1-0{,}50) \times 40} \approx 22 \text{ segundos}

Com tempo variável (M/M/1, mesma média): Wq ≈ 45 segundos. Padronizar o processo de dispensação cortou o tempo de espera à metade.


Exemplo: Caixa de supermercado (tempo padronizado)

15 clientes/hora, tempo fixo de 3 min por cliente (μ = 20/h).

ρ=0,75WqM/D/1=4,5 minvsWqM/M/1=9 min\rho = 0{,}75 \qquad W_q^{M/D/1} = 4{,}5 \text{ min} \quad \text{vs} \quad W_q^{M/M/1} = 9 \text{ min}

Treinar caixas para atingir um tempo padronizado de atendimento reduz a espera percebida pela metade — sem contratar ninguém.


Exemplo: Pedágio com pagamento eletrônico

120 carros/hora por pista. Passagem leva sempre 20 segundos (μ = 180/h).

ρ=120180=0,667Wq≈20 segundos\rho = \frac{120}{180} = 0{,}667 \qquad W_q \approx 20 \text{ segundos}

Se o sistema caísse para cobrança manual (tempo variável, mesma média), Wq dobraria para ~40 s. Em horários de pico com λ = 160 carros/h (ρ = 0,889), o M/D/1 dá Wq ≈ 1,3 min; o M/M/1 daria ~2,7 min.


Exemplo: Linha de montagem cadenciada

25 peças/hora chegam a uma estação com tempo de ciclo fixo de 2 minutos (μ = 30/h).

ρ=2530=0,833WqM/D/1≈5 minvsWqM/M/1≈10 min\rho = \frac{25}{30} = 0{,}833 \qquad W_q^{M/D/1} \approx 5 \text{ min} \quad \text{vs} \quad W_q^{M/M/1} \approx 10 \text{ min}

A estação está operando a 83% de capacidade. Se a demanda subir para 28 peças/h (ρ = 0,933), Wq do M/D/1 já vai para 14 min — gargalo crítico.

Por que o M/D/1 tem exatamente metade da fila do M/M/1?

A fórmula P-K geral é:

Lq=ρ2+λ2⋅Var[S]2(1−ρ)L_q = \frac{\rho^2 + \lambda^2 \cdot \text{Var}[S]}{2(1-\rho)}

Para M/M/1: Var[S]=1/μ2\text{Var}[S] = 1/\mu^2 → termo extra = ρ² → soma fica 2ρ² → Lq = ρ²/(1−ρ).

Para M/D/1: Var[S]=0\text{Var}[S] = 0 → só o primeiro termo → Lq = ρ²/[2(1−ρ)].

A variabilidade zero do serviço elimina metade da fila. Isso explica por que protocolos padronizados (scripts de atendimento, automação, takt time industrial) reduzem filas sem aumentar a velocidade média de serviço.

Como verificar se o serviço é “suficientemente fixo” para usar M/D/1

Meça o CV do tempo de serviço a partir de uma amostra:

CV medidoErro ao usar M/D/1 em vez do modelo correto
CV < 0,15< 2% — M/D/1 é preciso
0,15 ≤ CV < 0,45–20% — M/D/1 subestima levemente a fila
0,4 ≤ CV < 0,720–50% — use Erlang-k ou M/G/1
CV ≥ 0,7> 50% — use M/M/1 ou M/G/1 com Lognormal

↑ Voltar à trilha de estudo


Modelo M/M/1/K — capacidade máxima finita

📌 Em resumo — Use quando: existe um limite físico de lugares (sala de espera, buffer). · Fórmula-chave: bloqueio PKP_K e λef=λ(1−PK)\lambda_{ef}=\lambda(1-P_K) · Armadilha: com ρ > 1, aumentar K não resolve — o bloqueio tende a 1−1/ρ1-1/\rho; e se cada lugar atende alguém ao mesmo tempo (vagas, leitos), o modelo certo é o Erlang-B.

Quando usar: o sistema tem um limite físico — vagas de estacionamento, assentos de sala de espera, buffer de chamadas, quantidade de pedidos em processamento.

Fórmulas

P0=1−ρ1−ρK+1P(n)=P0⋅ρnPK=P0⋅ρKλeff=λ(1−PK)P_0 = \frac{1-\rho}{1-\rho^{K+1}} \quad P(n) = P_0 \cdot \rho^n \quad P_K = P_0 \cdot \rho^K \quad \lambda_{eff} = \lambda(1-P_K)

Exemplo: Estacionamento com 15 vagas — atenção ao modelo

10 carros/hora chegam. Permanência média: 2 horas (μ = 0,5/h). Capacidade: 15 vagas.

Cada vaga atende um carro ao mesmo tempo, então cada vaga é um servidor — não é uma fila com um único servidor. O modelo certo é M/M/15/15 (Erlang-B), com a = λ/μ = 20 Erlangs:

B(15; 20)≈33%B(15;\ 20) \approx 33\%

Um em cada três carros encontra o estacionamento lotado. Para bloqueio ≤ 5% seriam necessárias 26 vagas. Se a demanda triplicar (λ = 30), o bloqueio com 15 vagas chega a ~75%.


Exemplo: Buffer de chamadas (M/M/1/5)

50 chamadas/hora chegam a 1 atendente com μ = 20/h. Fila máxima: 5 posições.

ρ=5020=2,5PK≈60,2%\rho = \frac{50}{20} = 2{,}5 \qquad P_K \approx 60{,}2\%

Mais da metade das chamadas é bloqueada. Aumentar K não resolve: com ρ > 1, o bloqueio tende a 1 − 1/ρ = 60% por maior que seja a fila — o atendente simplesmente não dá conta. A alavanca é capacidade: com 2 atendentes (M/M/2/5) o bloqueio cai para ~28%; com 3 (M/M/3/5, ρ = 0,833), para ~14%, com Wq ≈ 0,6 min.

Exemplo: Sistema de pedidos online com limite de concurrent orders

Plataforma de e-commerce aceita no máximo K = 100 pedidos simultâneos. λ = 80 pedidos/min; cada pedido ocupa um worker por 1 min em média (μ = 1/min).

Com 1 worker só, ρ = 80: o K finito impede que o sistema “exploda”, mas ~99% dos pedidos seriam rejeitados — capacidade finita garante estabilidade, não atendimento. O dimensionamento real é pelo número de workers:

Workers (c)ModeloPedidos rejeitadosWq
1M/M/1/100~98,8%~99 min
80M/M/80/100~3,1%~5 s
90M/M/90/100~0,7%< 1 s
100M/M/100/100~0,4%0

Dimensionamento de K versus c

Para sistemas M/M/1/K, há dois alavancas independentes: aumentar K (mais espaço de espera) ou aumentar c (mais servidores):

AçãoEfeito em P(bloqueio)Efeito em Wq
Aumentar K↓ Bloqueio↑ Wq (mais gente espera)
Aumentar c↓ Bloqueio↓↓ Wq (atende mais rápido)

Moral: aumentar K sem aumentar c reduz perdas mas aumenta a espera dos que entram. Em aplicações onde o custo de espera é alto (saúde, tempo real), c é a alavanca certa.

Exemplo: UPA — sala de espera com capacidade limitada

20 cadeiras na sala de espera. 10 pacientes chegam por hora, 1 médico com μ = 3/h. K = 21 (20 cadeiras + 1 em atendimento).

ρ=103=3,33PK≈70%\rho = \frac{10}{3} = 3{,}33 \qquad P_K \approx 70\%

Sete em cada dez pacientes encontram a sala cheia e vão para outra unidade — e quem entra espera horas. Mais cadeiras não resolvem; mais médicos sim: com 2 (M/M/2/21) o bloqueio cai para ~40%, com 3 para ~11% e com 4 (ρ = 0,83) para ~0,5%, com Wq ≈ 17 min.

↑ Voltar à trilha de estudo


Modelo M/M/c/c — Erlang-B (sem fila, perda pura)

📌 Em resumo — Use quando: quem não encontra servidor livre vai embora (ramais, leitos, licenças). · Fórmula-chave: recursão de Erlang-B B(c,a)B(c,a), com a=λ/μa=\lambda/\mu em Erlangs. · Armadilha: não use para quem espera — aí o modelo é o Erlang-C.

Quando usar: chegadas em excesso são perdidas, não esperadas — ramais PABX, leitos hospitalares por especialidade, mesas de restaurante, licenças de software concurrent users.

Fórmula de Erlang-B

B(c,a)=a⋅B(c−1,a)c+a⋅B(c−1,a)B(0,a)=1a=λμB(c, a) = \frac{a \cdot B(c-1, a)}{c + a \cdot B(c-1, a)} \qquad B(0,a) = 1 \qquad a = \frac{\lambda}{\mu}

Exemplo: Ramais PABX

Escritório com 4 ramais. 30 chamadas/hora, duração média 5 min (μ = 12/h). a = 2,5 Erlangs.

Ramais (c)Bloqueio
328,2%
415,0%
57,0%
62,8%
71,0%

Com 4 ramais, cerca de 1 em cada 7 chamadas cai no “ocupado”. Para ≤ 2% de bloqueio (padrão comercial): 7 ramais.


Exemplo: Leitos de UTI

10 leitos. 2 internações/dia chegam. Permanência média 5 dias (μ = 0,2/dia). a = 10 Erlangs.

LeitosBloqueio
1021,5%
145,7%
153,6%
180,7%
22< 0,1%

Com 10 leitos, 1 em cada 5 pacientes críticos não encontra vaga. Para bloqueio < 5%: 15 leitos. Esse tipo de cálculo é usado no planejamento de capacidade hospitalar.


Exemplo: Mesas de restaurante no horário de pico

20 mesas. 40 grupos chegam/hora no pico. Refeição média: 45 min (μ = 1,33 grupos/hora/mesa). a ≈ 30 Erlangs.

B(20, 30) ≈ 38% dos grupos não encontram mesa.

Para ≤ 10% de bloqueio: ~32 mesas. Alternativa prática: sistema de reservas reduz a chegada aleatória (Poisson → determinístico), cortando drasticamente o excesso.


Exemplo: Licenças concurrent de software

Empresa tem 4 licenças floating de um ERP. 10 usuários tentam acessar/hora, cada sessão dura 20 min (μ = 3/h). a = 10/3 ≈ 3,33 Erlangs.

B(4, 3,33) ≈ 24% dos acessos bloqueados. Com 6 licenças: bloqueio cai para ~7%. Com 8: ~1,4%.

Como a fórmula de Erlang-B é calculada iterativamente

A recursão de Jagerman é numericamente estável para c grande:

B(0,a)=1B(n,a)=a⋅B(n−1,a)n+a⋅B(n−1,a)n=1,2,…,cB(0, a) = 1 \qquad B(n, a) = \frac{a \cdot B(n-1, a)}{n + a \cdot B(n-1, a)} \qquad n = 1, 2, \ldots, c

Isso evita o overflow de ac/c!a^c / c! para valores grandes de aa e cc — relevante em dimensionamento de redes com dezenas de circuitos.

Regra prática de Erlang-B para planejamento rápido

Para bloqueio ≤ 2% (padrão comercial telecom):

Tráfego (Erlangs)Circuitos necessáriosMargem sobre a
144×
5102×
10171,7×
50611,22×
1001131,13×

Efeito de economia de escala: ao dobrar o tráfego, o número de circuitos necessários cresce menos que o dobro — sistemas maiores são mais eficientes em termos de utilização por circuito.

Erlang-B vs Erlang-C — quando usar cada um

CritérioErlang-B (M/M/c/c)Erlang-C (M/M/c)
Chegadas em excessoSão perdidasAguardam em fila
ExemplosPABX, leitos, licenças, mesasCall center, guichês, caixas
Métrica de interesseProbabilidade de bloqueioTempo de espera (Wq)
SLA típicoBloqueio ≤ 2%Wq ≤ T segundos com P ≥ 80%
Consequência do excessoCliente desiste/vai emboraCliente espera (pode abandonar depois)

↑ Voltar à trilha de estudo


Distribuições não-exponenciais — M/G/1 e M/G/c

📌 Em resumo — Use quando: o tempo de atendimento não é exponencial e você conhece o CV. · Fórmula-chave: P-K Lq=ρ2(1+CV2)/[2(1−ρ)]L_q=\rho^2(1+CV^2)/[2(1-\rho)]; para c servidores, Kingman multiplica o M/M/c por (1+CV2)/2(1+CV^2)/2. · Armadilha: CV > 1 é pior que o exponencial — meça o CV nos seus dados.

Na prática, nem sempre o tempo de serviço segue uma distribuição exponencial. A ferramenta permite selecionar sete distribuições no campo “Distribuição do tempo de serviço”, todas com resultados analíticos via fórmulas P-K e Kingman:

DistribuiçãoParâmetrosCV típicoQuando usar
Exponencialμ1,00Padrão M/M/c — alta variabilidade aleatória
Erlang-kk fases, μ1/√kServiços com k etapas sequenciais de duração igual
Weibullα (forma), β (escala)depende de αVida útil de equipamentos, tempos de reparo
Lognormalμln, σlndepende de σlnTarefas cognitivas, atendimentos com cauda longa
Normal truncadaμ, σbaixo (< 1)Processos bem treinados com pequena variabilidade
Triangularmín, moda, máxbaixoEstimativas por especialista sem dados históricos
Uniformea, b1/√3 ≈ 0,58Serviços com tempo garantidamente entre a e b

Coeficiente de Variação (CV = σ/média)

O CV é o indicador-chave. A ferramenta exibe o CV = valor ao lado do seletor em tempo real.

  • CV < 1: tempos mais previsíveis que o exponencial → fila menor que M/M/c
  • CV = 1: equivalente ao exponencial → resultados idênticos ao M/M/c
  • CV > 1: tempos mais variáveis → fila maior que M/M/c

Fórmula Pollaczek-Khinchine (M/G/1)

Para 1 servidor e qualquer distribuição com média E[S] = 1/μ e variância Var[S]:

Lq=λ2⋅E[S2]2(1−ρ)ondeE[S2]=1+CV2μ2L_q = \frac{\lambda^2 \cdot \mathrm{E}[S^2]}{2(1-\rho)} \qquad \text{onde} \quad \mathrm{E}[S^2] = \frac{1+CV^2}{\mu^2}

Wq=LqλW=Wq+1μL=λWW_q = \frac{L_q}{\lambda} \qquad W = W_q + \frac{1}{\mu} \qquad L = \lambda W

Quando CV = 1 (exponencial), a fórmula P-K reproduz exatamente o M/M/1.

Aproximação de Kingman VCA (M/G/c)

Para c servidores paralelos, a aproximação de Kingman corrige o M/M/c pelo CV:

LqM/G/c≈LqM/M/c⋅1+CV22L_q^{M/G/c} \approx L_q^{M/M/c} \cdot \frac{1 + CV^2}{2}

O fator (1 + CV²)/2 vale exatamente 1 para CV = 1 (exponencial) e reduz para 0,5 quando CV → 0 (tempo constante, equivalente a M/D/c). Esta aproximação tem erro tipicamente < 5% para ρ < 0,90.

Exemplo: call center com tempos de atendimento lognormais

80 chamadas/hora, 7 atendentes, μ = 15/h (ρ = 0,76). Dados históricos mostram CV = 1,8 (cauda longa típica de chamadas técnicas).

ModeloLqWq
M/M/c (CV = 1)1,3159 s
M/G/c com CV = 1,8 (Kingman)2,78125 s

A variabilidade real mais que dobra o tempo de espera. Com 8 atendentes, o Wq com CV = 1,8 cai para ~42 s. (Com só 4 atendentes, ρ = 1,33 — o sistema seria instável.)

Exemplo: linha de montagem com Erlang-4

25 peças/hora, 1 estação, cada operação tem 4 etapas iguais em série de ~30 s cada (μ = 30/h, k = 4 → CV = 0,5).

LqM/G/1=LqM/M/1⋅1+0,522=LqM/M/1×0,625L_q^{M/G/1} = L_q^{M/M/1} \cdot \frac{1 + 0{,}5^2}{2} = L_q^{M/M/1} \times 0{,}625

Com a distribuição Erlang-4 a fila é 37,5% menor do que o M/M/1 estimaria. Modelar corretamente a distribuição pode mudar significativamente a decisão sobre adicionar servidores.

↑ Voltar à trilha de estudo


Guia rápido: qual modelo usar?

Há fila física possível?
├── NÃO → M/M/c/c (Erlang-B)      ramais, leitos, mesas, licenças
└── SIM
    ├── Há capacidade máxima K?
    │   └── SIM → M/M/1/K          estacionamento, buffer, sala de espera finita
    └── NÃO (fila ilimitada)
        ├── Distribuição do tempo de serviço
        │   ├── Exponencial (CV ≈ 1)
        │   │   ├── 1 servidor → M/M/1
        │   │   └── c servidores → M/M/c (Erlang-C)
        │   ├── Fixo/constante (CV = 0) → M/D/1
        │   └── Geral (Erlang, Weibull, Lognormal, Normal, Triangular, Uniforme)
        │       ├── 1 servidor → P-K formula (M/G/1)
        │       └── c servidores → Kingman VCA (M/G/c)

↑ Voltar à trilha de estudo


Ajuste de distribuição — qual modelo usar

Antes de escolher o modelo, determine se suas chegadas e tempos de serviço seguem Poisson/Exponencial. A seção “Ajuste de distribuição” analisa automaticamente sua amostra:

Coeficiente de Variação (CV = σ/média)

CV medidoDistribuição sugeridaModelo indicado
CV < 0,15Quase constanteM/D/1 ou M/D/c
0,15 ≤ CV < 0,65Erlang-k (k ≈ 1/CV²)M/Ek/c (use simulação)
0,65 ≤ CV < 1,35Exponencial (Markoviana)M/M/c
CV ≥ 1,35Hiper-exponencialSimulação DES recomendada

Teste de Kolmogorov-Smirnov

Para CV ≈ 1, o KS testa formalmente se os dados são compatíveis com exponencial a 95% de confiança — exibindo D observado vs. D crítico.

Como usar

  1. Colete tempos entre chegadas sucessivas (ou tempos de serviço)
  2. Cole os valores no campo (vírgula, ponto-e-vírgula ou quebra de linha)
  3. Clique “Analisar” — a ferramenta retorna CV, histograma, sugestão e KS
  4. Clique “Aplicar λ/μ” para preencher o parâmetro e recalcular

↑ Voltar à trilha de estudo


Como coletar dados para modelagem — passo a passo

A qualidade do modelo depende da qualidade dos dados. Fórmulas perfeitas com parâmetros errados geram resultados inúteis.

Passo 1 — Definir o escopo do sistema

Antes de medir, responda:

  • O que é uma entidade? (cliente, pedido, peça, requisição)
  • Onde ela entra no sistema? (porta, API endpoint, início da linha)
  • Onde ela sai? (atendimento concluído, entrega, resposta enviada)
  • Quem são os servidores? (atendentes, máquinas, threads)

Passo 2 — Medir λ (taxa de chegada)

Método direto: registre o horário de cada chegada durante o período de análise. Divida o total pelo tempo.

Ferramentas: planilha com timestamp, log de sistema (grep + awk), vídeo com contador, catracas automáticas.

Cuidados:

  • Meça em diferentes dias e horários — λ varia (use o modo NHPP se variar > 2×)
  • Identifique sazonalidades (semana vs. fim de semana, mês do ano)
  • Descarte períodos atípicos (feriados, promoções, incidentes)
  • Amostra mínima recomendada: 30 períodos do mesmo tipo (30 picos de segunda-feira, por exemplo)

Passo 3 — Medir μ (taxa de serviço)

Método direto: cronometre o tempo de início e fim de cada atendimento. μ = 1 / média dos tempos.

Atenção: meça o tempo de serviço puro (não incluindo espera). Em sistemas com log, é departure_time − service_start_time.

Cuidados:

  • Amostras mínimas: 30–50 atendimentos para CV estável
  • Meça por servidor se houver diferença de velocidade (μ₁ ≠ μ₂)
  • Identifique bimodalidades (atendimentos simples vs. complexos) — se CV > 1,5, considere separar em dois tipos ou usar M/G/1 com Lognormal
  • Exclua interrupções (pausa do atendente, sistema travado) do tempo de serviço

Passo 4 — Validar com Kolmogorov-Smirnov

Com a amostra coletada, use o botão 🔬 Análise de distribuição para:

  1. Verificar se os tempos entre chegadas seguem Poisson (KS test)
  2. Verificar se os tempos de serviço seguem exponencial
  3. Obter o CV real e a distribuição mais adequada

Interpretação do KS:

  • D < D_crítico (p > 0,05): hipótese de exponencial não rejeitada — use M/M/c
  • D > D_crítico: a distribuição é diferente da exponencial — use M/G/1/M/G/c com o CV medido

Passo 5 — Calibrar e validar o modelo

Após configurar a ferramenta com os parâmetros medidos:

  1. Rode a simulação com N = 300 entidades
  2. Compare o Wq simulado com o Wq medido no sistema real
  3. Se o erro for < 15%, o modelo está calibrado — use as fórmulas para análise de cenários
  4. Se o erro for > 15%, revise: (a) λ medido no período certo? (b) há multiservidor não modelado? (c) há prioridades ignoradas?

Referência rápida de tamanho de amostra

ParâmetroMínimo aceitávelIdealPor quê
Chegadas (para λ)100 chegadas500+CV de λ decai como 1/√n
Tempos de serviço (para μ e CV)30 observações100+Estabilidade do CV e do KS test
Períodos de medição (para NHPP)5 períodos15+Média horária estável
Réplicas de simulação (para IC 95%)1030IC proporcional a 1/√R

↑ Voltar à trilha de estudo


Retorno sobre Investimento (ROI) — quando vale adicionar um servidor?

A decisão de aumentar c (mais servidores/atendentes) é essencialmente uma análise de custo-benefício. A ferramenta fornece todos os inputs para esse cálculo.

Modelo de custo total

Defina:

  • hsh_s = custo horário de um servidor (salário + encargos + equipamento)
  • heh_e = custo horário de uma entidade esperando (produtividade perdida, custo de oportunidade, penalidade por SLA, risco de abandono)
  • λ = taxa de chegada (entidades/hora)

O custo total por hora é:

C(c)=c⋅hs+λ⋅Wq(c)⋅heC(c) = c \cdot h_s + \lambda \cdot W_q(c) \cdot h_e

O número ótimo de servidores minimiza C(c). Calcule C(c) para c = c_min até c_max usando os valores de Wq da tabela comparativa.

Exemplo: central de atendimento de seguros

λ = 50 ligações/hora, μ = 6/h, hsh_s = R35/h(atendente),35/h (atendente),h_e=R = R 80/h (cliente esperando = custo de churn + NPS)

AtendentesρWq (min)Custo servidores/hCusto espera/hTotal/h
992,6%11,4R$ 315R$ 760R$ 1.075
1083,3%2,9R$ 350R$ 195R$ 545
1175,8%1,1R$ 385R$ 75R$ 460
1269,4%0,5R$ 420R$ 32R$ 452
1364,1%0,2R$ 455R$ 14R$ 469

O ponto ótimo neste exemplo é 12 atendentes (custo mínimo de R452/h).Passarde10para11economizaR 452/h). Passar de 10 para 11 economiza R 85/h — o 11º atendente se paga rapidamente.

Custo de abandono (impatient customers)

Em sistemas reais, clientes que esperam muito abandonam. A taxa de abandono aumenta com Wq. Uma aproximação simples:

Receita perdida=λ⋅P(abandono)⋅R\text{Receita perdida} = \lambda \cdot P(\text{abandono}) \cdot R

onde R é a receita média por atendimento e P(abandono) cresce com Wq. Se o Wq simulado (use a aba de simulação) revelar que 15% dos clientes saem antes de 3 minutos e cada atendimento vale R$ 200:

Receita perdida=50×0,15×200=R$ 1.500/hora\text{Receita perdida} = 50 \times 0{,}15 \times 200 = \text{R\$ 1.500/hora}

Esse valor, somado ao custo de espera, justifica facilmente a contratação do atendente adicional.

Payback de automação (redução de μ)

Se a automação reduz o tempo de serviço de 5 min para 3 min (μ sobe de 12/h para 20/h), o impacto no Wq é equivalente a adicionar vários servidores — com custo fixo e sem variabilidade de RH. Compare o investimento em automação com o payback em redução de custo de espera e/ou redução de headcount necessário.

↑ Voltar à trilha de estudo


Erros mais comuns — e como evitá-los

Erro 1: Usar λ médio quando há sazonalidade forte

Problema: λ = 60/h no pico e λ = 10/h no vale. A média ponderada de 35/h leva a um dimensionamento que funciona bem no vale mas colapsa no pico.

Solução: configure o perfil NHPP com ⏱ λ variável no tempo e simule para ver o Wq em cada período. Dimensione para o pico que você se dispõe a absorver.

Erro 2: Medir o tempo de espera incluindo o tempo de serviço

Problema: o cronômetro começa na chegada e para na saída → obtém W (tempo total), não Wq (tempo de espera puro).

Solução: registre separadamente arrival_time, service_start_time e departure_time. Wq = service_start − arrival. W = departure − arrival.

Erro 3: Usar M/M/1 quando há múltiplos servidores paralelos

Problema: calcular ρ = λ/(c·μ) e aplicar a fórmula M/M/1 com esse ρ reduzido. Subestima dramaticamente a fila — o M/M/c concentra o efeito da variabilidade de forma diferente.

Solução: use sempre M/M/c com o c correto. Para c = 1 ambos coincidem.

Erro 4: Ignorar o período de warm-up na simulação

Problema: a simulação começa com fila vazia. As primeiras 50–100 entidades têm Wq = 0 artificialmente, puxando a média para baixo.

Solução: ative o warm-up nas configurações de simulação. Regra: warm-up ≥ 5 / (μc − λ) em unidades de tempo.

Erro 5: Confundir bloqueio com abandono

Problema: o M/M/c supõe que clientes esperam indefinidamente. Na realidade, clientes com paciência finita abandonam a fila. Ignorar isso subestima a taxa de perda real.

Solução: use a simulação com NHPP e adicione lógica de abandono (impaciência). Como aproximação, note que o Wq simulado sem abandono é um limite superior — a fila real é menor porque alguns clientes saem.

Erro 6: Usar as fórmulas com ρ ≥ 1 e interpretar os resultados

Problema: quando ρ ≥ 1, as fórmulas retornam resultados negativos ou infinitos. Não há interpretação válida.

Solução: leia o alerta vermelho “sistema instável” e dimensione para ρ < 1 primeiro. Somente depois refine os parâmetros.

Erro 7: Comparar Wq analítico com lead time medido no sistema real

Problema: o lead time medido inclui retrabalho, interrupções, múltiplas filas encadeadas. O Wq analítico é apenas para uma fila isolada.

Solução: use o modo de rede de filas para modelar múltiplos estágios encadeados. Some os Wq de cada etapa para o tempo total de espera.


1. Como converter entre unidades de tempo?

Mantenha λ e μ na mesma unidade. Se λ = 90/hora e quiser trabalhar em minutos: λ = 1,5/min, μ = 15/60 = 0,25/min. Todos os resultados de W e Wq ficam na unidade escolhida. A ferramenta exibe automaticamente em s, min ou h conforme a magnitude.

2. Qual distribuição de serviço escolher?

Use o ajuste automático de distribuição (botão 🔬): cole uma amostra de tempos de serviço e a ferramenta calcula o CV e sugere a distribuição. Referência rápida:

CV medidoDistribuição sugerida
CV ≈ 0 (< 0,15)Determinístico → use M/D/1
0,15–0,65Erlang-k com k ≈ 1/CV²
0,65–1,35Exponencial → M/M/c
> 1,35Hiper-exponencial ou Lognormal → use distribuição Lognormal na ferramenta

Para qualquer distribuição escolhida, a ferramenta calcula automaticamente os KPIs analíticos via P-K (c=1) ou Kingman (c>1) e permite simular para validar.

3. O sistema é instável (ρ ≥ 1). O que fazer?

Três opções: (1) Aumentar μ — reduzir o tempo de atendimento; (2) Aumentar c — servidores em paralelo; (3) Reduzir λ — agendamento, triagem ou roteamento. A tabela comparativa de servidores (resultado M/M/c) mostra quantitativamente o impacto de adicionar cada servidor.

4. Qual a diferença entre Erlangs e ρ?

Erlangs (a = λ/μ) é o tráfego total oferecido — pode ser > 1. ρ (= a/c) é a utilização por servidor, entre 0 e 1. O Erlang-B usa a; o Erlang-C usa ambos.

5. Quando usar simulação em vez de fórmulas?

Use simulação quando: (a) quer validar os resultados analíticos; (b) o sistema tem múltiplas etapas encadeadas (rede de filas); (c) há prioridades ou roteamento complexo; (d) λ e μ variam ao longo do dia; (e) quer ver a distribuição completa de Wq (percentis), não apenas a média. Para os modelos cobertos pelas fórmulas, os resultados analíticos e de simulação convergem com N ≥ 300 — o que valida a modelagem.

6. Como o Arena se relaciona com esta ferramenta?

Arena e Simul8 usam DES para casos arbitrariamente complexos. A simulação integrada nesta ferramenta usa o mesmo princípio para os modelos básicos. Para os modelos cobertos por fórmulas fechadas, os resultados analíticos e de simulação convergem com N suficiente — o que valida a modelagem antes de levar para ferramentas mais complexas.

7. Como dimensionar uma equipe de manutenção?

Use M/M/c com λ = taxa de chamados e μ = taxa de atendimento por técnico. A tabela comparativa exibe Wq para c-1, c, c+1, c+2. Compare o custo marginal de um técnico com o custo horário de máquina parada: custo_parada × Wq × λ = custo de máquina parada por hora.

8. Como calcular SLA de tempo de espera para M/M/c?

P(Wq≤T)=1−C(c,a)⋅e−(cμ−λ) TP(W_q \leq T) = 1 - C(c,a)\cdot e^{-(c\mu-\lambda)\,T}

Para encontrar o menor c que garante 80% dos clientes com Wq ≤ 20 s, use a tabela comparativa e identifique o menor c em que essa probabilidade supera 80%.

9. Quando usar λ variável no tempo (NHPP)?

Use o perfil NHPP sempre que λ variar significativamente ao longo do dia ou da semana — call centers, restaurantes, servidores web, pedágios, prontos-socorros. Regra prática: se o λ do pico for mais de 2× o λ médio, as fórmulas com λ constante subestimam o tempo de espera de pico. Configure o perfil com ⏱ λ variável no tempo e use 🎲 Simular para ver Wq em cada período.

↑ Voltar à trilha de estudo


Comparação de Cenários — Process Analyzer com IC 95%

O Process Analyzer (seção “Comparação de Cenários”) permite avaliar múltiplas configurações do sistema em paralelo — o equivalente ao Process Analyzer do Arena e ao Scenario Manager do Simul8.

O que é um cenário?

Um cenário é uma variação dos parâmetros atuais com overrides específicos: você define a configuração base (formulário principal) e cada cenário aplica alterações pontuais — ex: aumentar λ em 20%, adicionar 1 servidor, melhorar μ em 10%.

Campos configuráveis por cenário:

ParâmetroSignificado
λTaxa de chegada do cenário (substitui a global)
μTaxa de serviço do cenário
cNúmero de servidores do cenário
modeloHerdado da configuração base

Replicações e Intervalo de Confiança

Cada cenário é rodado RR vezes (replicações), cada uma com NN entidades. As estatísticas de saída (WqW_q, LqL_q, ρ\rho) variam entre réplicas por causa da aleatoriedade. O IC 95% é calculado via t-Student com df = R − 1:

Wq‾±tR−1, 0.025⋅sR\overline{W_q} \pm t_{R-1,\,0.025} \cdot \frac{s}{\sqrt{R}}

onde ss é o desvio padrão amostral entre réplicas.

Parâmetros recomendados:

  • Réplicas R: 10–20 para exploração inicial; 30–50 para decisões de investimento
  • Entidades N: 300–500 para IC estreito; aumentar se o CV for alto (>25%)

Quando usar

  • Dimensionamento de capacidade: comparar c=2 vs c=3 com os ICs — se os ICs não se sobrepõem, a diferença é estatisticamente significativa
  • Análise de sensibilidade: quanto o Wq piora se λ crescer 20%? E se μ cair 10%?
  • Planejamento de pico: simular o cenário “Pico de demanda” com λ×1.3 e verificar se ρ < 1
  • Business case: exportar o CSV e comparar custo de servidores vs. redução de Wq

Interpretação da tabela

  • Fundo vermelho: ρ ≥ 1 — sistema instável, fila cresce indefinidamente
  • Fundo amarelo: ρ ≥ 0.9 — risco de saturação em picos transientes
  • IC estreito (CV < 10%): estimativa confiável — poucas réplicas são suficientes
  • IC largo (CV > 25%): aumente o número de réplicas ou de entidades

Dica: Use o analítico (fórmulas fechadas) para triagem rápida e o simulador (replicações) para validar e obter ICs reais — especialmente quando ρ > 0.8, onde as fórmulas M/M/c superestimam a estabilidade.

↑ Voltar à trilha de estudo


Simulação de Eventos Discretos (DES)

O botão 🎲 Simular abre uma simulação DES completa — o mesmo princípio do Arena e Simul8, executado no navegador.

Como funciona

  • Chegadas homogêneas: intervalo entre chegadas = −ln(U)/λ (transformada inversa da exponencial)
  • Chegadas não-homogêneas (NHPP): método de Lewis-Shedler (thinning) — gera candidatos com λ_max e aceita cada um com probabilidade λ(t)/λ_max, respeitando o perfil de chegada por período
  • Serviço exponencial: amostra por transformada inversa
  • Erlang-k: soma de k amostras exponenciais de taxa k·μ
  • Weibull, Lognormal, Normal, Triangular, Uniforme: amostras por transformada inversa ou aceitação-rejeição
  • Alocação: servidor mais cedo disponível; se todos ocupados → fila virtual
  • Bloqueio: M/M/1/K rejeita quando cheio; M/M/c/c rejeita quando todos os servidores ocupados

O que os resultados mostram

SaídaSignificado
Simulação vs AnalíticoValida as fórmulas para os parâmetros dados
Histograma de WqDistribuição completa da espera (percentis reais)
Fila × tempoEvolução dinâmica — identifica rajadas e períodos de folga
Taxa de bloqueio simuladaProporção real de entidades rejeitadas

Para análises críticas, use N = 500 entidades. Concordância dentro de ±10% com o analítico confirma que os parâmetros estão corretos.

↑ Voltar à trilha de estudo


Taxas de chegada variáveis no tempo (NHPP)

Em muitos sistemas reais, λ não é constante ao longo do dia — call centers têm pico na manhã, restaurantes no almoço, servidores web pico em horário comercial. A ferramenta implementa um Processo de Poisson Não-Homogêneo (NHPP) via o botão ⏱ λ variável no tempo no painel de parâmetros.

Como configurar o perfil de chegada

  1. Clique em ⏱ λ variável no tempo abaixo do campo λ
  2. No modal, defina períodos com rótulo, duração e taxa λ — os períodos são cíclicos (ex.: 24h se repetem a cada dia)
  3. O mini gráfico de barras atualiza em tempo real (largura ∝ duração do período)
  4. Clique ✓ Aplicar perfil — o badge λ̄ = X.XX/h aparece ao lado do botão confirmando a ativação

Cálculo analítico vs simulação NHPP

ModoO que usaQuando usar
Fórmulas (analítico)λ médio ponderado λ̄ = Σ(λᵢ·dᵢ)/Σ(dᵢ)Estimativa rápida de dimensionamento
🎲 SimularNHPP via Lewis-Shedler thinningAnálise precisa do impacto do perfil horário

O λ médio ponderado é exato para dimensionamento em regime estacionário. A simulação NHPP revela o impacto dinâmico: nos períodos de pico, a fila cresce; nos vales, esvazia. A diferença entre o Wq máximo de pico e o Wq médio pode ser 3–10× dependendo do perfil.

Exemplo: call center com perfil diário

Perfil: 08h–10h (λ=80/h), 10h–12h (λ=50/h), 12h–14h (λ=30/h), 14h–18h (λ=60/h), restante (λ=10/h). μ=15/h, c=6 atendentes.

  • λ médio ponderado do horário comercial (08h–18h) ≈ 56/h → ρ ≈ 62% → Wq analítico ≈ 24 s (parece confortável)
  • Simulação NHPP no pico 08h–10h: ρ ≈ 89% → Wq de pico ≈ 4,3 min

A análise com λ constante subestima dramaticamente o impacto do pico. Com NHPP + simulação, descobre-se que são necessários 8 atendentes para manter Wq < 30 s durante o pico matutino (com 7, o pico fica em ~1 min).

Método de Lewis-Shedler (thinning)

O algoritmo gera um processo de Poisson homogêneo com taxa λ_max = max(λ₁, λ₂, …, λₙ) e, para cada evento candidato no instante t, aceita-o com probabilidade λ(t)/λ_max:

P(aceitar em t)=λ(t)λmax⁡P(\text{aceitar em } t) = \frac{\lambda(t)}{\lambda_{\max}}

O resultado é um processo não-homogêneo exato. O tempo t é avaliado módulo o período total do ciclo, tornando o perfil cíclico e compatível com simulações de múltiplos dias.

↑ Voltar à trilha de estudo


Período de Warm-up — Regime Transiente vs. Estacionário

Todo sistema de filas real passa por uma fase inicial chamada regime transiente: logo após a abertura (ou reinicialização), a fila começa vazia e o comportamento ainda não reflete o padrão de longo prazo. À medida que o sistema opera, as estatísticas convergem para o regime estacionário — o equilíbrio estatístico descrito pelas fórmulas de M/M/1, M/M/c etc.

Por que isso importa?

Se você mede Lq, Wq e ρ incluindo o período de aquecimento, os valores aparecem artificialmente melhores do que a realidade operacional. Um caixa de supermercado medido nos primeiros 10 minutos após a abertura terá fila quase zero — mas esse dado não representa o meio do dia.

Como a ferramenta trata o warm-up

Nos Parâmetros de Simulação, acima do botão Calcular, você define:

CampoO que representa
Duração totalJanela de tempo da operação (ex.: 480 min = turno de 8h)
Warm-upPeríodo inicial descartado das estatísticas (ex.: 60 min)

A ferramenta exibe automaticamente: “KPIs calculados sobre X min (pós warm-up)”.

Curva de convergência Lq(t)

O gráfico “Lq ao longo do tempo” mostra a evolução teórica do comprimento médio da fila usando a aproximação:

Lq(t)=Lq∞⋅(1−e−αt)Lq(t) = Lq_{\infty} \cdot \left(1 - e^{-\alpha t}\right)

onde α = μ · c · (1 − ρ) é a taxa de convergência do sistema. Quanto maior α (servidores rápidos, utilização baixa), mais rápida a estabilização.

A área amarela representa o período de warm-up. A linha tracejada horizontal marca Lq∞ (valor estacionário).

Badge de regime

BadgeSignificado
🟢 EstacionárioO warm-up definido é suficiente para cobrir 95% da convergência
🟡 TransienteO warm-up é curto — as estatísticas ainda carregam influência do estado inicial

A fronteira é o tempo t₉₅ = −ln(0,05) / α, que representa o instante em que o sistema já atingiu 95% do valor estacionário de Lq.

Regra prática

Para sistemas com ρ > 0,8, o tempo de estabilização pode ser longo. Uma heurística comum em simulações industriais é usar 10–20% da duração total como warm-up — ou até a primeira vez em que a fila esvazia completamente após a abertura.

↑ Voltar à trilha de estudo


Filas com Prioridade — Disciplina PRIO e Tipos de Entidade

O que é disciplina de fila?

Em sistemas reais, nem todo cliente espera a mesma coisa na mesma fila. A disciplina de fila define a ordem de atendimento:

DisciplinaSiglaComportamento
Primeiro a chegar, primeiro a ser atendidoFIFOOrdem de chegada — todos os tipos têm o mesmo Wq
Prioridade (não-preemptiva)PRIOClientes de maior prioridade ficam à frente; quem está em atendimento não é interrompido
Último a chegar, primeiro a ser atendidoLIFOÚtil para modelar pilhas (stacks) — ex.: inventário em armazém

Múltiplos tipos de entidade

Quando o sistema atende clientes de diferentes tipos (Regular, VIP, Urgente), cada tipo possui:

  • Proporção (%) — fração do fluxo total de chegadas: λk=λ×pk\lambda_k = \lambda \times p_k
  • Prioridade — nível 1 a 5 (maior = atendido primeiro no modo PRIO)
  • μ próprio (opcional) — taxa de serviço específica para o tipo (ex.: VIP com atendimento mais rápido)

Fórmula de Kleinrock (M/M/1, PRIO não-preemptiva)

Para uma fila M/M/1 com KK classes de prioridade ordenadas de maior para menor, defina:

ρk=λkμk,σ0=1,σj=1−∑i=1jρi\rho_k = \frac{\lambda_k}{\mu_k}, \qquad \sigma_0 = 1, \qquad \sigma_j = 1 - \sum_{i=1}^{j} \rho_i

O tempo médio de espera na fila para a classe kk é:

Wq(k)=R0σk−1⋅σkW_q^{(k)} = \frac{R_0}{\sigma_{k-1} \cdot \sigma_k}

onde R0=∑kλkμk2R_0 = \sum_k \dfrac{\lambda_k}{\mu_k^2} é o tempo residual de serviço ponderado.

O número médio na fila por tipo segue pela Lei de Little: Lq(k)=λk⋅Wq(k)L_q^{(k)} = \lambda_k \cdot W_q^{(k)}.

Para M/M/c (c > 1): a ferramenta escala o resultado acima pelo ratio WqMMc/WqMM1W_q^{MMc} / W_q^{MM1} — uma aproximação conservadora. Para precisão máxima, use a simulação (🎲 Simular).

Condição de estabilidade com prioridades

O sistema é estável se ρtotal=∑kρk<1\rho_{total} = \sum_k \rho_k < 1.
Atenção: para as classes mais baixas o denominador σk−1⋅σk\sigma_{k-1} \cdot \sigma_k pode se aproximar de zero, fazendo Wq(k)→∞W_q^{(k)} \to \infty antes mesmo do sistema global ficar instável — é o fenômeno de starvation (inanição).

Exemplo

Banco com λ = 30 clientes/hora, μ = 15/hora, 3 servidores (M/M/3, ρ = 0,667; com 2 servidores ρ = 1 e o sistema seria instável):

TipoProporçãoλₖPrioridadeWq estimado
Regular70%21/h1 — padrão~2,2 min
VIP20%6/h2 — alto~0,8 min
Urgente10%3/h3 — crítico~0,6 min

Em FIFO, todos esperariam ~1,8 min. Com prioridade, o VIP espera ~64% menos que o Regular e o Urgente ~72% menos — e o Regular passa a esperar um pouco mais que no FIFO.

Quando usar PRIO vs. FIFO

  • FIFO: quando todos os clientes têm o mesmo valor e justiça é prioritária
  • PRIO: call centers com SLA diferenciado, urgências hospitalares, sistemas de TI com tickets críticos, logística com entregas prioritárias
  • LIFO: modelagem de estoques LIFO, buffers de rede com descarte de pacotes mais antigos

↑ Voltar à trilha de estudo


Roteamento Condicional — Como as Entidades Escolhem o Próximo Estágio

Em uma rede de filas real, nem toda entidade percorre todos os estágios. Um paciente pode ser liberado após a triagem sem passar pela consulta; 30% dos pedidos podem ir para o depósito A e 70% para o B. Isso é roteamento condicional.

Três tipos de roteamento

TipoSímboloQuando usar
Serial→ 100%Todas as entidades passam para o próximo estágio — fluxo obrigatório
Probabilístico→ p%Cada entidade tem probabilidade fixa p de entrar no estágio — independente de atributos
Regra (atributo)→ se attr op valA decisão depende de um atributo da entidade (prioridade, classe, etc.)

Probabilístico — divisão de fluxo

Se o roteamento entre estágio ii e estágio i+1i+1 tem fração pp, o λ efetivo do estágio i+1i+1 é:

λi+1=λsaıˊda,i×p\lambda_{i+1} = \lambda_{\text{saída},i} \times p

onde λsaıˊda,i=λi×(1−Pbloqueio,i)\lambda_{\text{saída},i} = \lambda_i \times (1 - P_{\text{bloqueio},i}).

Exemplos: triagem hospitalar onde 40% são liberados sem consulta; call center onde 60% são resolvidos no nível 1 e 40% escalam para especialista; e-commerce com depósitos paralelos.

Regra (atributo)

A entidade carrega um atributo (prioridade, peso, classe) e, ao sair de um estágio, a condição é avaliada: se verdadeira, entra no próximo estágio; caso contrário, sai do sistema ou vai para rota alternativa.

Para o cálculo analítico, usa-se uma fração estimada p^\hat{p} — a proporção de entidades que satisfaz a condição. O modelo trata como probabilístico com p=p^p = \hat{p}.

λVIP=λ×p^VIP,λregular=λ×(1−p^VIP)\lambda_{\text{VIP}} = \lambda \times \hat{p}_{\text{VIP}}, \quad \lambda_{\text{regular}} = \lambda \times (1 - \hat{p}_{\text{VIP}})

Exemplo numérico: banco com 100 clientes/hora, 20% VIP (prioridade ≥ 2). O caixa VIP recebe λ=20\lambda = 20/hora; o regular, λ=80\lambda = 80/hora.

Quando usar cada tipo

  • Serial: fluxo obrigatório, todas as entidades percorrem todas as etapas (linha de produção sequencial, pipeline de microserviços)
  • Probabilístico: fluxo aleatório sem distinção por tipo — abandono espontâneo, round-robin, amostragem aleatória para QA
  • Regra: fluxo diferenciado por tipo de entidade — triagem médica (urgente/não-urgente), SLA diferenciado (VIP/standard), filas de suporte por nível de complexidade

Atenção: Com roteamento probabilístico, o λ total do sistema se reduz. Verifique a condição de estabilidade de cada estágio separadamente — o gargalo pode mudar com o roteamento.

↑ Voltar à trilha de estudo


Recursos com Turnos, Breaks e Falhas (Downtime)

Em sistemas reais, servidores não ficam disponíveis 24 h por dia com capacidade constante. Uma linha de produção opera em três turnos com equipes diferentes; um call center tem menos atendentes à noite; uma máquina para periodicamente para manutenção. Ignorar isso superestima a capacidade real e subestima o tempo de espera.

Turnos de trabalho

Um turno define um intervalo de tempo (início–fim, em minutos desde meia-noite ou desde o início da simulação) e quantos servidores estão ativos nesse período. A tabela de turnos é cíclica — ao fim do último turno o ciclo reinicia automaticamente.

ConceitoSignificado
Início / FimLimite do turno em minutos dentro de um ciclo diário (0 = meia-noite)
Servidores ativosNúmero de servidores disponíveis durante o turno

Regra prática: não deixe turnos com gap (horário sem cobertura) a não ser que seja intencional — entidades que chegam nesse período encontram 0 servidores e ficam bloqueadas.

O número efetivo de servidores no instante tt da simulação é:

c(t)=cturno(t mod T)c(t) = c_{\text{turno}(t \bmod T)}

onde TT é a duração total do ciclo de turnos.

Falhas e Manutenção

Falhas são modeladas por dois parâmetros:

ParâmetroSignificado
MTBF (Mean Time Between Failures)Tempo médio entre falhas — quanto tempo o servidor opera sem parar. Amostrado por distribuição exponencial.
MTTR (Mean Time To Repair)Tempo médio de reparo — quanto tempo o servidor fica indisponível após uma falha. Também exponencial.

Durante um evento de falha, o servidor afetado fica indisponível por um período MTTR e as entidades que chegariam a ele precisam esperar ou migrar para outro servidor disponível.

Disponibilidade teórica do recurso (sem considerar turnos):

A=MTBFMTBF+MTTRA = \frac{\text{MTBF}}{\text{MTBF} + \text{MTTR}}

O downtime percentual exibido na interface é 1−A1 - A. Por exemplo, MTBF = 240 min e MTTR = 30 min resultam em A=0,889A = 0{,}889 — 11 % do tempo o servidor está em reparo.

Impacto nas métricas

Com turnos e falhas, a utilização efetiva do servidor aumenta mesmo sem mudar λ\lambda ou μ\mu, porque a capacidade disponível diminui. Um sistema estável em teoria pode se tornar instável na prática se a disponibilidade for baixa:

ρefetivo=λμ⋅c⋅A\rho_{\text{efetivo}} = \frac{\lambda}{\mu \cdot c \cdot A}

Para sistemas com turnos, a ferramenta usa Simulação de Eventos Discretos para calcular WqW_q, LqL_q e ρ\rho — as fórmulas analíticas M/M/c supõem capacidade constante e não se aplicam diretamente.

Quando usar

  • Turnos: linhas de produção, call centers, supermercados com abertura/fechamento, hospitais com plantões
  • Falhas: máquinas industriais, equipamentos médicos, servidores de TI, guichês sujeitos a lentidão sistêmica

↑ Voltar à trilha de estudo


Teoria das Filas: Exercícios Resolvidos Passo a Passo

Esta seção apresenta exercícios clássicos de teoria das filas com resolução completa — do enunciado ao resultado, passando por cada fórmula aplicada. Ideal para estudantes de pesquisa operacional, engenharia de produção e administração.


Exercício 1 — M/M/1: Caixa de supermercado (nível básico)

Enunciado: Um supermercado tem 1 caixa. Chegam em média 18 clientes por hora (processo de Poisson). O atendimento demora em média 2,5 minutos por cliente. Calcule: (a) utilização do caixa, (b) tempo médio de espera na fila, (c) número médio de clientes aguardando.

Ver resolução

Dados:

  • λ = 18 clientes/hora
  • μ = 60/2,5 = 24 clientes/hora
  • Modelo: M/M/1

Resolução:

(a) Utilização: ρ=λμ=1824=0,75=75%\rho = \frac{\lambda}{\mu} = \frac{18}{24} = 0{,}75 = 75\%

O caixa está ocupado 75% do tempo.

(b) Tempo médio de espera na fila (Wq): Wq=λμ(μ−λ)=1824×(24−18)=18144=0,125 h=7,5 minutosW_q = \frac{\lambda}{\mu(\mu - \lambda)} = \frac{18}{24 \times (24 - 18)} = \frac{18}{144} = 0{,}125 \text{ h} = \mathbf{7{,}5 \text{ minutos}}

(c) Número médio aguardando (Lq): Lq=λ⋅Wq=18×0,125=2,25 clientesL_q = \lambda \cdot W_q = 18 \times 0{,}125 = \mathbf{2{,}25 \text{ clientes}}

Conclusão: Com utilização de 75%, o cliente espera em média 7,5 min antes de ser atendido. Se o fluxo subir para 22 clientes/hora (ρ = 91,7%), Wq dispara para 27,5 minutos — o efeito exponencial da utilização.

Verifique com a ferramenta: configure λ = 18, μ = 24, servidores = 1 e confirme os valores. O gráfico de Sensibilidade Wq × λ mostrará visualmente o ponto de colapso.


Exercício 2 — M/M/c: Call center com múltiplos atendentes (nível intermediário)

Enunciado: Um call center recebe 48 ligações por hora. Cada atendente resolve uma ligação em 6 minutos em média. Quantos atendentes são necessários para que no máximo 15% das ligações esperem mais de 30 segundos? (SLA: P(Wq > 30s) ≤ 15%)

Ver resolução

Dados:

  • λ = 48 ligações/hora
  • μ = 10 ligações/hora por atendente
  • a = λ/μ = 4,8 Erlangs
  • Alvo: P(Wq > 30s) ≤ 15%

Resolução:

Trafego em Erlangs: a=48/10=4,8 Ea = 48/10 = 4{,}8\text{ E}

Testando c = 6 atendentes: ρ=4,8/6=0,80\rho = 4{,}8/6 = 0{,}80

Erlang-C(6; 4,8) ≈ 0,518 → P(esperar) = 51,8%

P(Wq>30s)=C(c,a)⋅e−(cμ−λ)⋅t=0,518⋅e−(60−48)⋅(30/3600)≈0,518⋅e−0,1≈46,8%P(W_q > 30s) = C(c,a) \cdot e^{-(c\mu - \lambda) \cdot t} = 0{,}518 \cdot e^{-(60-48) \cdot (30/3600)} \approx 0{,}518 \cdot e^{-0{,}1} \approx 46{,}8\%

❌ Com 6 atendentes o SLA não é atingido.

Testando c = 7 atendentes: ρ=4,8/7=0,686\rho = 4{,}8/7 = 0{,}686

Erlang-C(7; 4,8) ≈ 0,278

P(Wq>30s)≈0,278⋅e−(70−48)⋅(30/3600)≈0,278⋅e−0,183≈23,2%P(W_q > 30s) \approx 0{,}278 \cdot e^{-(70-48) \cdot (30/3600)} \approx 0{,}278 \cdot e^{-0{,}183} \approx 23{,}2\%

❌ Com 7 atendentes, 23% das ligações ainda esperam mais de 30 s.

Testando c = 8 atendentes: ρ=0,60\rho = 0{,}60, Erlang-C(8; 4,8) ≈ 0,140 → P(Wq > 30s) ≈ 10,7% ✅

Resposta: 8 atendentes — o menor número que cumpre o SLA de 15%.

Configure na ferramenta: λ = 48, μ = 10, varie c de 6 a 8. Use a aba “Comparação de Cenários” para ver a tabela lado a lado.


Exercício 3 — M/M/c/c (Erlang-B): Dimensionamento de ramais PABX (nível intermediário)

Enunciado: Uma empresa gera 3,5 Erlangs de tráfego telefônico. Qual o número mínimo de ramais para que a probabilidade de bloqueio (sinal de ocupado) seja menor que 1%?

Ver resolução

Dados:

  • a = 3,5 Erlangs
  • Modelo: M/M/c/c (Erlang-B) — sem fila, chamadas bloqueadas são perdidas
  • Alvo: B(c, 3,5) < 0,01

Tabela de Erlang-B:

Ramais (c)B(c, 3,5)
426,0% ❌
515,4% ❌
68,2% ❌
74,0% ❌
81,7% ❌
90,7% ✅

Resposta: 9 ramais garantem P(bloqueio) < 1%.

Na ferramenta: selecione modelo Erlang-B (M/M/c/c), configure a = 3,5 e veja a tabela de bloqueio por número de ramais.


Exercício 4 — Lei de Little: medição inversa (nível básico)

Enunciado: Um banco observa que, em horário de pico, há em média 12 clientes no sistema (fila + atendimento). O tempo médio total (espera + atendimento) é de 18 minutos. Qual é a taxa de chegada de clientes?

Ver resolução

Aplicando a Lei de Little:

L=λ⋅W  ⟹  λ=LW=1218/60=120,3=40 clientes/horaL = \lambda \cdot W \implies \lambda = \frac{L}{W} = \frac{12}{18/60} = \frac{12}{0{,}3} = \mathbf{40 \text{ clientes/hora}}

Interpretação: Sem cronometrar chegadas diretamente, basta contar clientes presentes e medir o tempo médio que ficam — a Lei de Little fornece λ. Útil para auditoria de sistemas existentes.


Exercício 5 — M/D/1: Linha de produção cadenciada (nível intermediário)

Enunciado: Uma estação de montagem recebe peças a uma taxa Poisson de 20 peças/hora. O tempo de processamento é fixo: exatamente 2,5 minutos por peça. Calcule Lq e compare com o modelo M/M/1.

Ver resolução

Dados:

  • λ = 20 peças/hora
  • Tempo fixo: 2,5 min → μ = 24 peças/hora
  • ρ = 20/24 = 0,833
  • Modelo: M/D/1 (tempo de serviço determinístico)

Fórmula de Pollaczek-Khinchine para M/D/1:

LqM/D/1=ρ22(1−ρ)=0,83322×0,167=0,6940,334≈2,08 pec¸asL_q^{M/D/1} = \frac{\rho^2}{2(1-\rho)} = \frac{0{,}833^2}{2 \times 0{,}167} = \frac{0{,}694}{0{,}334} \approx \mathbf{2{,}08 \text{ peças}}

Comparação com M/M/1:

LqM/M/1=ρ21−ρ=0,6940,167≈4,15 pec¸asL_q^{M/M/1} = \frac{\rho^2}{1-\rho} = \frac{0{,}694}{0{,}167} \approx \mathbf{4{,}15 \text{ peças}}

Conclusão: o tempo fixo (M/D/1) gera metade da fila do tempo variável (M/M/1) com a mesma utilização. Padronizar tempos de serviço é uma das intervenções de maior impacto na redução de filas sem adicionar capacidade.


Exercício 6 — Análise de sensibilidade: interpretando o gráfico Wq × λ

Enunciado: Um sistema M/M/3 tem μ = 10/hora por servidor. Trace mentalmente a curva Wq em função de λ e identifique o ponto de colapso.

Ver resolução

Ponto de colapso: quando λ → c·μ = 30, o denominador de Wq → 0 e a fila cresce sem limite.

λ (chegadas/h)ρWq aproximado
100,33~0,3 min
200,67~2,7 min
250,83~8,4 min
270,90~16 min
290,97~56 min
301,00∞

Essa curva é exatamente o gráfico Sensitivity Wq × λ exibido na ferramenta — o ponto vermelho indica sua configuração atual, e a curva revela quanto espaço existe até o colapso. Use este gráfico para identificar a margem de segurança operacional.

Exercício prático: configure λ = 25, μ = 10, c = 3 na ferramenta. Observe o ponto vermelho no gráfico de sensibilidade. Depois arraste λ para 28 e veja o ponto subir na curva exponencial.


Para encontrar outras calculadoras e simuladores úteis para produtividade, estudos e pesquisa operacional, veja o mapa de ferramentas online gratuitas do Utilibox.

↑ Voltar à trilha de estudo


Glossário de Teoria das Filas

TermoSímboloDefinição
Taxa de chegadaλNúmero médio de chegadas por unidade de tempo. Unidade: entidades/tempo.
Taxa de serviçoμNúmero médio de atendimentos que um servidor realiza por unidade de tempo.
Número de servidorescServidores paralelos idênticos atendendo a mesma fila.
Tráfego oferecidoaa = λ/μ (em Erlangs). Tráfego que o sistema recebe, independentemente de c.
Utilização por servidorρρ = λ/(c·μ). Fração do tempo que cada servidor fica ocupado. Estável se ρ < 1.
Número médio na filaLqEntidades aguardando atendimento (não incluindo as em serviço).
Número médio no sistemaLEntidades aguardando + em atendimento. L = Lq + λ/μ.
Tempo médio na filaWqTempo médio que uma entidade espera antes de ser atendida.
Tempo médio no sistemaWTempo médio total (espera + serviço). W = Wq + 1/μ.
Lei de LittleL = λWVálida para qualquer sistema estável, independente do modelo.
Erlang (unidade)E1 E = 1 circuito ocupado durante 1 hora. a = λ/μ em Erlangs.
Erlang-BB(c,a)Probabilidade de bloqueio em sistema M/M/c/c (sem fila).
Erlang-CC(c,a)Probabilidade de ter que esperar em sistema M/M/c (com fila).
Coeficiente de variaçãoCVCV = σ/média do tempo de serviço. CV = 1 para exponencial.
Regime estacionário—Estado de equilíbrio estatístico após warm-up. As fórmulas descrevem este estado.
Regime transiente—Estado inicial, antes da estabilização. Estatísticas dependem do tempo.
Processo de PoissonMChegadas com intervalos exponenciais independentes. A = M na notação de Kendall.
NHPP—Non-Homogeneous Poisson Process — Poisson com λ variando no tempo.
DES—Discrete Event Simulation — simulação que avança de evento em evento.
FIFO—First In, First Out — disciplina padrão de atendimento por ordem de chegada.
PRIO—Priority — entidades de maior prioridade são atendidas antes.
Warm-up—Período inicial descartado das estatísticas para evitar distorção do regime transiente.
BloqueioP_KProbabilidade de uma entidade ser rejeitada por falta de capacidade.
Intervalo de confiançaIC 95%Intervalo que contém o verdadeiro valor com 95% de probabilidade, calculado via t-Student.
MTBF—Mean Time Between Failures — tempo médio de operação sem falha.
MTTR—Mean Time To Repair — tempo médio de reparo após falha.
DisponibilidadeAA = MTBF / (MTBF + MTTR). Fração do tempo em que o recurso está operacional.
Starvation—Fenômeno em sistemas com prioridade: entidades de baixa prioridade esperam indefinidamente.
Kingman VCA—Variational-Coefficient Approximation de Kingman para M/G/c.
P-K—Fórmula de Pollaczek-Khinchine para M/G/1 com distribuição geral de serviço.
Teorema de Jackson—Em redes de filas Jackson, cada nó M/M/c se comporta como fila independente.
Roteamento probabilísticopFração p das entidades segue para o próximo estágio.
Abandono—Entidade sai da fila antes de ser atendida (impaciência). Não modelado pelas fórmulas padrão.
Takt time—Tempo disponível / demanda. Define o ritmo máximo de produção. = 1/λ_max.
WIP—Work In Progress — número de itens em processamento simultâneo. WIP = L pela Lei de Little.

↑ Voltar à trilha de estudo


Por que este é o melhor simulador de filas online gratuito

Nenhuma outra ferramenta gratuita combina, sem instalação, os recursos que este simulador oferece:

RecursoUtiliQueueCalculadoras web gratuitasArena / Simul8
M/M/1, M/M/c, M/D/1, M/M/1/K, Erlang-B✅parcial✅
M/G/c (Weibull, Lognormal, Erlang-k…)✅❌✅
Simulação de Eventos Discretos (DES)✅❌✅
Animação em tempo real da fila✅❌✅
NHPP — λ variável por hora✅❌✅
Filas com prioridade (VIP, urgência)✅❌✅
Redes de filas — série, paralelo, condicional✅❌✅
Ajuste de distribuição com teste KS✅❌❌
Tabela comparativa multi-servidor✅❌❌
Tutorial guiado de 24 passos✅❌❌
Gratuito para testar, sem instalação✅✅❌
Funciona no celular✅parcial❌

Arena e Simul8 custam milhares de reais por ano e exigem instalação em Windows. JaamSim e SimPy são gratuitos, mas exigem programação. Este simulador entrega 24 das 24 características avaliadas em comparação com 10 ferramentas do mercado — pontuação máxima entre todas as ferramentas gratuitas e empatando ou superando as comerciais em acessibilidade.

Quando usar este simulador vs. Arena/Simul8

Use este simulador quando você precisa:

  • Dimensionar rapidamente call centers, filas de banco, guichês, leitos de UTI, pedágios
  • Validar com DES se o sistema tem distribuições não-exponenciais ou carga variável
  • Modelar uma rede de produção com etapas em série, paralelo ou roteamento condicional
  • Ensinar teoria das filas — os 22 cenários pré-configurados e o tutorial de 24 passos são ideais para sala de aula

Use Arena/Simul8 quando você tem: sistemas com centenas de filas interligadas com feedback loops complexos, modelagem 3D de fábricas ou lógica de negócio altamente customizada que exige scripting avançado.

↑ Voltar à trilha de estudo


Breve história — de Copenhagen ao século XXI

1909 — Erlang e o telefone

Agner Krarup Erlang era engenheiro da Copenhagen Telephone Company quando formulou o problema: quantos circuitos são necessários para atender as chamadas de uma cidade sem que o sinal de ocupado apareça com frequência inaceitável? Sua resposta — a fórmula de Erlang-B — calculou pela primeira vez a probabilidade de bloqueio em sistemas de perda pura. Em 1917, estendeu o trabalho para sistemas com fila (Erlang-C).

A unidade de tráfego Erlang (E) leva seu nome até hoje: 1 Erlang = 1 circuito ocupado durante 1 hora completa = λ/μ.

1950s–1970s — Expansão para manufatura e computação

Com o advento dos computadores mainframe, David Kendall (1953) propôs a notação A/S/c que padronizou a área. John Little (1961) provou o teorema que leva seu nome — válido para qualquer sistema estável. Jackson (1963) estendeu a teoria para redes de filas, abrindo o caminho para modelagem de sistemas de produção, computadores e telecomunicações.

1970s–1980s — Call centers e sistemas M/G/c

Erlang-C se tornou o padrão da indústria para dimensionamento de call centers. A fórmula de Pollaczek-Khinchine (P-K) e a aproximação de Kingman tornaram tratável o caso M/G/c com distribuição geral de serviço. Computadores permitiram calcular tabelas de Erlang para c até 100+ servidores.

1990s–2000s — Simulação de Eventos Discretos (DES)

Ferramentas como Arena (Siman/1982, Arena/1993) popularizaram a Simulação de Eventos Discretos — capacidade de modelar sistemas com rotas, prioridades, recursos múltiplos e distribuições arbitrárias, muito além do que as fórmulas fechadas suportam. Empresas passaram a simular fábricas inteiras antes de construí-las.

2010s–hoje — Web, microsserviços e IA

A teoria das filas ressurgiu em engenharia de software: dimensionamento de thread pools, análise de latência de microserviços, auto-scaling em nuvem (AWS CloudWatch, GCP Load Balancer) e circuit breakers todos têm raízes nos modelos M/M/c e M/G/c. O conceito de Little’s Law virou pilar do movimento DevOps para medir lead time e WIP.

↑ Voltar à trilha de estudo