Single Server Poisson Model – 1
(M/M/1) (∞ / FIFO)

P₀ = 1 – (λ/μ)   where P₀  denotes the probability of system being idle.

P_n = (λ/μ)ⁿ P₀  = (λ/μ)ⁿ {1 – (λ/ μ)}

The quantity λ/μ = ρ is called the traffic intensity.

Average number L_s of customers in the system

L_s    =  E(n) =  ∑_n^∞₌₀  nP_n  = λ/(μ- λ)

Average number L_q of customers in the queue

L_q  = E(n) =  ∑_n^∞₌₀  (n-1)P_n  = λ²/{μ (μ- λ)} or  L_s – (λ/μ)

 Average number L_w of customers in the nonempty queue

 L_w  = E{(N-1)/(N-1)>0}  = μ / (μ- λ)

 Probability that the number of customers in the system exceeds k

P(n > k) =  ∑_n^∞_=k+1  P_n    = ρ^k+1

 Probability density function of the waiting time in the system:

 f(w) = ∑_n^∞₌₀  f(w/n) P_n =   (μ- λ) e^{-(μ -λ)w}

 Average waiting time W_s of a customer in the system

 W_s  = 1 / (μ- λ)

 Average waiting time W_q of a customer in the queue

 W_q  =  / λ/{μ (μ- λ)}

 Probability that the waiting of a customer in the system exceeds t.

 P(W_s > t) = _t∫^∞   f(w) dw  = e^{-(μ -λ)t}

 Little’s Formula:

L_s   =   λ/(μ- λ)                =  λ W_s

L_s   =  λ/(μ- λ)                = L_q  + λ/μ

W_s =   1 / (μ- λ)             =  W_q + 1/μ

L_q   =   λ²/{μ (μ- λ)}  =  λ W_q

Model – 2  (M/M/C) (∞ / FCFS):

 P₀ = 1/ [∑_n^c-1₌₀ (1/n!) (λ/μ)ⁿ] + [(λ/μ)^c (1/c!{1- λ/cμ})]  

 P_n =  (1/c!c^n-c) (λ/μ)ⁿ P₀         If n ≥ c

 Average number L_s of customers in the system :

 L_s    =   [(1/c!c) (λ/μ)^c+1 P₀ {1/ (1- λ/μc)²}] + λ/μ

 Average number L_q of customers in the queue:

 L_q  =  (1/c!c) (λ/μ)^c+1 P₀ {1/ (1- λ/μc)²}

 Average Time a customer spends in the system:

 W_s = (1/λ) L_s  =   [(1/μc!c) (λ/μ)^c P₀ {1/ (1- λ/μc)²}] + 1/μ

 Average Time a customer spends in the Queue:

 W_q = (1/λ) L_q  =   (1/μc!c) (λ/μ)^c P₀ {1/ (1- λ/μc)²}

 Probability that an arrival has to wait:

P(W_s > 0) =  P(n ≥ c)

                 =  (λ/μ)^c P₀  / c!(1- λ/μc)

 Probability that an arrival has to get the service without waiting:

 P(getting the service without waiting)  = 1 - P(Arrival has to wait)

              = 1 – {(λ/μ)^c P₀  / c!(1- λ/μc)}

 Probability that someone will be waiting:

 P(Someone will be waiting )  = P(n ≥ c+1)

                                                = ∑_n^∞_=c+1  P_n

= (λ/μ)^c (λ/μc) P₀  / {c!(1- λ/μc)}

 Mean waiting time in the queue for those who actually wait:

 E(W_q /W_s)  =  E(W_q )/P(W_s > 0)

                   = 1/(μc - λ)

 Average number of customers (in non-empty queues), who have to actually wait:

 L_w  = (λ/μc) /(1- λ/μc)

 Model – 3

(M/M/1) (N / FIFO)  (Finite capacity, single server Poisson queue model):

 P_n  =  (λ/μ)ⁿ  {(1- λ/μ) /(1- (λ/μ)^N+1)}

  P_n  =  1/(N+1)  for   λ  =  μ

 Probability that the system is idle:

 P₀ = (1 – r) / (1 – (ρ)^N+1)  where ρ  = λ/μ

 Average number L_s of customers in the system

L_s    =  E(n) = P_{0 *} ∑_n^N₌₀  n ρⁿ

         = [λ/(μ- λ)] – [(N+1) (λ/μ)^N+1/(1- (λ/μ)^N+1)]  for λ  ≠  μ

      = k/2   for   λ  =  μ

 Average queue length:

L_q   =  L_s – λ′/μ . λ′ =  μ(1- P₀) the effective arrival rate.

Average waiting time in the system:

W_s  =  L_s / λ′

Average waiting time in the queue:

W_q  =  L_q / λ′

 Average number of units in the system:

  L_s     = [λ/(m- 1)] – [(N+1) (1/m)^N+1/(1- (1/m)^N+1)] 

Average number of units in the queue:

 L_q   =  L_s – (1 - P₀)

Model – 4

(M/M/S) (K / FIFO)  or  (M/M/C) (N / FIFO)  :

 P₀ = [∑_n^s-1₌₀ (1/n!) (λ/μ)ⁿ  +(1/s!) (λ/μ)^s   ∑_n^k_=s  (λ/μ)^n-s   ]^-1

 P_n = (1/n!) (1/m)ⁿ  P₀                  For  n ≤ s

 P_n = (1/s! s^n-s) (1/m)ⁿ  P₀      For s < n ≤ k

 ρ =  1/ μs

 L_q   =  P₀ (1/m)^s (r/s!(1 - r )²) [ 1 - ρ^{k – s} – (k – s ) (1 – ρ) ρ^{k – s}]

 L_s   =   L_q + s [∑_n^s-1₌₀  ( s - n ) P_n]

 W_s  =  L_s / λ′

 λ′  =     μ  [ s - ∑_n^s-1₌₀  ( s - n ) P_n]

 Excess capacity or overflow occurs

 P(N= n) =  (1/s! s^n-2) (λ/μ)ⁿ  P₀      

 Non – Markovian Queueing Model 5

(M/G/1): (∞ / GD model)

 Pollaczek-Khinchine formula:

 L_s  =  E(N) = λ E(T) [λ² {Var(T) + (E(T)²} / 2{1 – λ E(T)}]