Analysis of a Markovian Queueing Model with an Alternating Server and Queue-Length-Based Threshold Control

Abstract

This paper analyzes a finite-capacity Markovian queueing system with two customer types, each assigned to a separate buffer, and a single alternating server whose service priority is dynamically controlled by a queue-length-based threshold policy. The arrivals of both customer types follow independent Poisson processes, and the service times are generally distributed. The server alternates between the two buffers, granting service priority to buffer 1 when its queue length exceeds a specified threshold immediately after service completion; otherwise, buffer 2 receives priority. Once buffer 1 gains priority, it retains it until it becomes empty, with all priority transitions occurring non-preemptively. We develop an embedded Markov chain model to derive the joint queue length distribution at departure epochs and employ supplementary variable techniques to analyze the system performance at arbitrary times. This study provides explicit expressions for key performance measures, including blocking probabilities and average queue lengths, and demonstrates the effectiveness of threshold-based control in balancing service quality between customer classes. Numerical examples illustrate the impact of buffer capacities and threshold settings on system performance and offer practical insights into the design of adaptive scheduling policies in telecommunications, cloud computing, and healthcare systems.

1. Introduction

A polling–queueing system, in which a single server cyclically serves multiple buffers according to a specified rule, has been extensively studied owing to its broad applicability. This system plays a crucial role in various domains, including telecommunications networks, where it optimizes data packet scheduling; healthcare triage systems, which ensure efficient patient prioritization; cloud computing resource allocation, where it dynamically distributes computing resources among tasks; and call centers, where it manages customer service queues to minimize waiting times. The versatility of polling systems makes them essential for optimizing resource utilization and improving service efficiency across diverse applications. Earlier reviews of polling models, including [1,2], provided foundational insights, while more recent surveys can be found in [3,4,5].

The polling–queueing model is typically applied to systems that serve two or more types of customers requiring distinct levels of service. For example, in telecommunications networks, voice traffic is sensitive to transmission delays, whereas data traffic is less so, necessitating differentiated services. A common method for achieving this differentiation is the use of priority queues. However, strict priority policies can significantly degrade the performance of lower-priority traffic [6], making it essential to design more balanced scheduling policies that meet the stringent requirements of high-priority traffic without unduly penalizing lower-priority requests.

Significant progress in creating balanced control policies has been achieved through threshold-based approaches. Among these, queue-length-based control policies are employed in polling systems to dynamically optimize performance and resource allocation across various industries. These policies are intuitive and the queue length can also be interpreted as the system’s workload when the processing times per customer are comparable. In telecommunications, adaptive packet scheduling in routers employs queue-length thresholds to ensure low-latency transmission for high-priority traffic, such as Voice over Internet Protocol (VoIP) packets, while deprioritizing best-effort data. Similarly, cloud computing uses queue-length thresholds to allocate resources dynamically, thereby ensuring optimal response times for latency-sensitive tasks [7]. Beyond digital applications, healthcare systems leverage queue-based triage models to adjust patient priorities dynamically [8], thereby reducing mortality rates in emergency care.

To illustrate the practical relevance of threshold-based control, consider a 5G network base station serving two types of traffic slices: enhanced Mobile Broadband (eMBB) for video streaming (class 1), requiring low latency, and massive Machine-Type Communications (mMTC) for IoT sensors (class 2), tolerating delays but with high volume. A strict-priority policy favoring eMBB causes severe mMTC packet loss during peak video usage, while first-come-first-served fails to meet eMBB latency requirements. A threshold-based policy resolves this: when eMBB queue length exceeds threshold L, the station prioritizes eMBB until the queue drains; otherwise, it serves mMTC. This prevents eMBB latency violations while ensuring mMTC data is not indefinitely starved. The threshold L is configured based on SLAs to balance both traffic types. Similar trade-offs arise in emergency departments (urgent vs. non-urgent patients), cloud computing (interactive vs. batch jobs), and data centers (latency-sensitive vs. throughput-oriented workloads).

Seminal works by researchers such as Avrachenkov et al. [9], who analyzed an $M/M/1$ model, and more recently by Boxma et al. [10], who investigated a sophisticated policy for a two-queue system, have contributed significantly. However, these studies often rely on simplifying assumptions that limit their direct applicability. For instance, the analysis in [9] is restricted to Markovian service times, while the model in [10] assumes a specific configuration of one finite (capacity 1) and one infinite buffer. In many real-world systems, service processes are often more general (non-exponential), and multiple competing services face finite resource constraints. This highlights a clear gap in the literature: a comprehensive analysis of a polling system with multiple finite buffers and general service time distributions.

To bridge this gap, this paper proposes and analyzes a queue-length-based threshold control policy for a more general and practical polling model. Our approach extends beyond the limitations of prior work by considering a system with two finite buffers and general service distributions ($M/G/1/K$-type). This model is highly relevant for the aforementioned real-world applications where resources are constrained and multiple, finite queues are common. The primary contributions of this work are threefold. First, we generalize the system model by incorporating two finite-capacity buffers with arbitrary sizes and general (non-exponential) service time distributions, a critical extension for realistically modeling resource-constrained systems where all buffers face capacity limits. Second, we develop an exact analytical solution by constructing a finite-state embedded Markov chain at departure epochs and applying supplementary variable techniques to derive steady-state distributions at arbitrary times. This approach successfully addresses the analytical challenge posed by the interaction of finite-capacity constraints, general service distributions, and threshold-based switching—a combination not previously solved in closed form. Third, we provide practical design insights by demonstrating how performance metrics (blocking probabilities, waiting times) are jointly influenced by buffer capacities and threshold settings, offering concrete guidance for system configuration in real-world applications.

The remainder of this paper is organized as follows. Section 2 presents a brief literature review. In Section 3, the mathematical model is described and formalized. The following section presents numerical examples. Finally, we conclude the paper.

2. Literature Review

Polling–queueing models have been widely used to analyze and optimize the performance of systems characterized by multiple input streams served by a single server. Such scenarios frequently occur in real-world applications where diverse input flows converge and require coordinated processing. Practical examples of polling-based systems include data centers [11], communication networks [12,13], logistics operations [14], tape-library systems [15], and intersection traffic signal management [16]. Numerous studies have been conducted to improve the efficiency of polling models. Recently, Uncu [17] investigated the load-balancing problem in a polling scheme applied to systems aimed at optimizing performance through simulation experiments. Wu et al. [18] addressed the server routing scheduling problem in distributed queueing systems with time-varying demands and stochastic travel times by proposing a dynamic programming model and a rollout heuristic algorithm. Their approach demonstrated effectiveness in reducing server working time and outperformed existing methods in large-scale scenarios. Dudin and Dudina [19] examined the problem of determining the optimal combination of server sojourn times for each class to minimize the sojourn time of a tagged customer in the system.

Research efforts have focused on developing more realistic models, such as generalized arrival and service processes, for example, two Markovian arrival processes (MAPs) and a phase-type service distribution, as assumed by [20]. They also considered the gated service discipline and switching times—the time required for the server to move from one buffer to another. A marked MAP was also considered by [19]. In addition to arrival and service processes, various polling–queuing system service policies are discussed in [21]. Dudin et al. [22] emphasized the importance of modeling realistic arrival patterns using a Batch-Marked Markov Arrival Process (BMMAP) to capture heterogeneous batch arrivals and inter-arrival correlations, and proposed a novel dynamic priority change mechanism for optimal system utilization strategies in a flexible limited processor sharing (FLPS) model. Although their analysis is not based on a polling model, their approach to modeling realistic arrivals and dynamic priorities is relevant for extending such considerations to polling systems.

Next, we review existing studies on switching policies in polling–queueing models. In such models, the buffer currently being served can be considered to have priority over others. Various policies exist for switching priorities between buffers. Takács [23] presented an exhaustive policy for an $M/G/1$ queue with two buffers, in which the server continues serving until there are no customers left in one buffer before moving on to the other. Eisenberg [24] proposed an alternating service policy for an $M/G/1$ model with two buffers, where the server serves one customer at a time from one buffer and then switches to the other. If one buffer is empty, the server remains at the other until a new customer arrives. Boon and Winands [25] investigated a polling model with two buffers under a K-limited policy. When a buffer has priority, the server serves up to K customers from that buffer before switching. If fewer than K customers are present, the server continues until the buffer is empty. Subsequently, Ozawa [26] introduced mixed service disciplines into the K-limited polling system. Of particular relevance to our work, Avrachenkov et al. [9] analyzed a threshold-based switching policy for a finite $M/M/1$ queueing model with two buffers. In their model, the server prioritizes the buffer with a shorter queue, and when one buffer’s queue length exceeds a specified threshold, the server switches to the other buffer. Their analysis provides valuable insights into threshold-based control for finite-capacity systems. However, their framework is restricted to exponential service time distributions, which limits its applicability to systems where service processes exhibit more general characteristics (e.g., deterministic, heavy-tailed, or phase-type distributions). Perel and Yechiali [27] also examined similar threshold policies in finite Markovian queues. Bruneel [6] considered a polling model with two buffers and a threshold policy, analyzing a discrete-time queueing model.

Recently, Boxma et al. [10] investigated a single-server, two-queue Markovian polling system with a novel threshold-based switching policy dependent on the state of the other queue. They assumed two classes of customers arrive according to independent, non-identical Poisson processes. Two queues, $Q_1$ and $Q_2$, were considered, with $Q_1$ having a capacity of one and $Q_2$ having infinite capacity. Service times were independently distributed and non-identical. The infinite queue $Q_2$ has a threshold value N. If both $Q_1$ and $Q_2$ are empty, the server serves the arriving customer regardless of type. The server serves $Q_2$ if it contains at least N customers. If a customer arrives at $Q_1$ while the server is serving $Q_2$ and $Q_2$ has fewer than N customers, the server switches to $Q_1$ in a preemptive manner. They derived the steady-state distribution of the number of customers in each queue and the sojourn time for each customer in the system. Our study extends this work in two ways to provide a more realistic and practical model. First, we consider two finite buffers with general capacities ($K_1,K_2\ge 1$) rather than restricting one buffer to a single position, which better reflects resource-constrained systems where both buffers have limited but non-trivial capacities. Second, we assume general (non-exponential) service time distributions, which are more realistic than exponential service for many practical applications.

3. Analysis of the Model

3.1. Model Description

Two separate buffers accommodate type-1 and type-2 customers. The arrivals of type-1 and type-2 customers follow independent Poisson processes with rates ${\lambda }_1$ and ${\lambda }_2$, respectively. The system is assumed to be initially empty–both buffers start with zero customers. Because the steady-state distribution of the underlying Markov process is independent of the initial state, this assumption does not affect the analytical results. Arriving customers are queued in buffers 1 and 2, which have finite capacities $K_1$ and $K_2$, depending on their type. Customers arriving when the buffer is full are blocked or lost. Customers in each buffer are served on a first-come, first-served basis according to their arrival order. The server is initially idle and begins serving upon the arrival of a customer, regardless of type. If one of the buffers is empty, customers from the non-empty buffer are served, regardless of their type.

The service priority between the two buffers is governed by the queue length of buffer 1 relative to the threshold L. Specifically, if the queue length of buffer 1 is below L (including empty), priority is given to buffer 2 and remains until buffer 1’s queue length reaches or exceeds L. At that point, service priority switches to buffer 1, which continues until buffer 1 becomes empty. Then, the priority switches back to buffer 2. Service priority transitions are handled in a non-preemptive manner.

Two extreme threshold settings merit special attention. Setting $L=1$ provides maximum priority for class 1, as buffer 1 gains priority immediately upon any arrival, resulting in minimal delays for class 1 but potentially longer waits for class 2. This is suitable for delay-sensitive applications such as VoIP traffic. Conversely, setting $L=K_1$ protects class 2 performance, since buffer 1 gains priority only when it is completely full. This reduces class 2 waiting times but may increase class 1 blocking probabilities, making it appropriate when class 2 requires consistent service and class 1 can tolerate delays. Intermediate thresholds enable flexible trade-offs between these extremes to match specific application requirements.

3.2. Mathematical Formulation

The service times for all customers are assumed to be independent and identically distributed with the distribution function $G(·)$, regardless of type. Let $\mu$ and $G^{*}\left(s\right)$ denote the mean and Laplace transform of the distribution function $G(·)$, respectively. Using the embedded Markov chain method, we first derive the queue length distribution at customer departure epochs, and then obtain the queue length distribution at an arbitrary time using the supplementary variable method.

3.2.1. Joint Queue Length Distribution at Departure Epochs

In this section, we derive the stationary joint queue length distribution at customer departure epochs. Let ${\tau }_n(n\ge 1)$ denote the time of the nth customer’s departure with ${\tau }_0=0$. We introduce the following notation:

$$\begin{array}{ccc}\hfill N_n^1& =& \mathrm{the}\mathrm{queue}\mathrm{length}\mathrm{of}\mathrm{buffer}1\mathrm{at}\mathrm{time}{\tau }_n^{+},\hfill \\ \hfill N_n^2& =& \mathrm{the}\mathrm{queue}\mathrm{length}\mathrm{of}\mathrm{buffer}2\mathrm{at}\mathrm{time}{\tau }_n^{+},\hfill \end{array}$$

$${\xi }_n=\left\{\begin{array}{c}1,\mathrm{if}\mathrm{service}\mathrm{priority}\mathrm{is}\mathrm{given}\mathrm{to}\mathrm{buffer}1\mathrm{at}\mathrm{time}{\tau }_n^{+},\hfill \\ 2,\mathrm{if}\mathrm{service}\mathrm{priority}\mathrm{is}\mathrm{given}\mathrm{to}\mathrm{buffer}2\mathrm{at}\mathrm{time}{\tau }_n^{+}.\hfill \end{array}\right.$$

Then, the process $\{(N_n^1,N_n^2,{\xi }_n),n\ge 0\}$ forms a Markov chain with a finite state space arranged in lexicographic order. Let

$$\begin{array}{ccc}\hfill a_{ij}& =& \mathrm{Pr}\{i\mathrm{arrivals}\mathrm{of}\mathrm{type}\text{-}1\mathrm{customers}\mathrm{and}\hfill \\ & & j\mathrm{arrivals}\mathrm{of}\mathrm{type}\text{-}2\mathrm{customers}\mathrm{during}\mathrm{a}\mathrm{service}\mathrm{time}\}\hfill \\ & =& {\int }_0^{\infty }{\displaystyle \frac{e^{-{\lambda }_{1}x}{\left({\lambda }_{1}x\right)}^i}{i!}}·{\displaystyle \frac{e^{-{\lambda }_{2}x}{\left({\lambda }_{2}x\right)}^j}{j!}}dG\left(x\right),\hfill \end{array}$$

and

$$a_{\overline{i},j}=\sum _{k=i}^{\infty }{a}_{k,j},a_{i,\overline{j}}=\sum _{k=j}^{\infty }{a}_{i,k},a_{\overline{i},\overline{j}}=\sum _{l=i}^{\infty }\sum _{m=j}^{\infty }{a}_{l,m}.$$

We define the steady-state probability of the Markov chain $\{(N_n^1,N_n^2,{\xi }_n),n\ge 0\}$ as

$$x_{i,j,r}=\underset{n\to \infty }{\lim }\mathrm{Pr}\{N_n^1=i,N_n^2=j,{\xi }_n=r\},0\le i\le K_1,0\le j\le K_2,r=1,2.$$

(1)

To facilitate further analysis, we introduce the vectors:

$$\begin{array}{ccc}\hfill x_{i,j}& =& (x_{i,j,1},x_{i,j,2}),\hfill \end{array}$$

(2)

$$\begin{array}{ccc}\hfill x_i& =& (x_{i,0},x_{i,1},\cdots x_{i,K_2}),\hfill \end{array}$$

(3)

$$\begin{array}{ccc}\hfill x& =& (x_0,x_1,\cdots ,x_{K_1}).\hfill \end{array}$$

(4)

Building on these definitions, we introduce additional matrices. First, the matrix $A_i$ for $0\le i\le L-1$ denotes the transitions from $\left\{(N_n^1=0,N_n^2,{\xi }_n)\right\}$ to $\left\{(N_{n+1}^1=i,N_{n+1}^2,{\xi }_{n+1})\right\}$. Since these transitions start from a state where buffer 1 is empty $N_n^1=0$, the service priority must be with buffer 2. Therefore, any state involving ${\xi }_n=1$ has zero probability. Furthermore, because the resulting queue length ($N_{n+1}^1=i$), is less than the threshold L, the service priority is maintained at buffer 2. As a result, states involving ${\xi }_{n+1}=1$ also have zero probability for these transitions.

$$\begin{array}{c}\hfill A_i=\left(\begin{array}{ccccccccccc}0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& a_{i,0}& 0& a_{i,1}& 0& a_{i,2}& \cdots & 0& a_{i,K_2-1}& 0& a_{i,\overline{K_2}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& a_{i,0}& 0& a_{i,1}& 0& a_{i,2}& \cdots & 0& a_{i,K_2-1}& 0& a_{i,\overline{K_2}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& a_{i,0}& 0& a_{i,1}& \cdots & 0& a_{i,K_2-2}& 0& a_{i,\overline{K_2-1}}\\ ⋮& ⋮& ⋮& ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& ⋮\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& a_{i,1}& 0& a_{i,\overline{2}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& a_{i,0}& 0& a_{i,\overline{1}}\end{array}\right),0\le i\le L-1.\end{array}$$

(5)

The matrix $A_i$ for $L\le i\le K_1-1$ represents transitions that start from an empty buffer 1 ($N_n^1=0$), where priority is initially with buffer 2. However, since the queue length of buffer 1 at the next $(n+1)$th departure epoch is greater than or equal to L, service priority is transferred to buffer 1.

$$\begin{array}{c}\hfill A_i=\left(\begin{array}{ccccccccccc}0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ a_{i,0}& 0& a_{i,1}& 0& a_{i,2}& 0& \cdots & a_{i,K_2-1}& 0& a_{i,\overline{K_2}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ a_{i,0}& 0& a_{i,1}& 0& a_{i,2}& 0& \cdots & a_{i,K_2-1}& 0& a_{i,\overline{K_2}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& a_{i,0}& 0& a_{i,1}& 0& \cdots & a_{i,k_2-2}& 0& a_{i,\overline{K_2-1}}& 0\\ ⋮& ⋮& ⋮& ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& ⋮\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& \cdots & a_{i,1}& 0& a_{i,\overline{2}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& \cdots & a_{i,0}& 0& a_{i,\overline{1}}& 0\end{array}\right),L\le i\le K_1-1.\end{array}$$

(6)

$$\begin{array}{c}\hfill B_0=\left(\begin{array}{ccccccccccc}0& a_{0,0}& 0& a_{0,1}& 0& a_{0,2}& \cdots & 0& a_{0,K_2-1}& 0& a_{0,\overline{K_2}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& a_{0,0}& 0& a_{0,1}& \cdots & 0& a_{0,K_2-2}& 0& a_{0,\overline{K_2-1}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& 0& 0& a_{0,0}& \cdots & 0& a_{0,K_2-3}& 0& a_{0,\overline{K_2-2}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ ⋮& ⋮& ⋮& ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& ⋮\\ 0& 0& 0& 0& 0& 0& \cdots & 0& a_{0,0}& 0& a_{0,\overline{1}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& a_{0,\overline{0}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\end{array}\right).\end{array}$$

(7)

The matrix $B_0$ represents the state transitions from $\left\{(N_n^1=1,N_n^2,{\xi }_n)\right\}$ to $\left\{(N_{n+1}^1=0,N_{n+1}^2,{\xi }_{n+1})\right\}$. In this case, the service priority can be assigned to either buffer 1 or buffer 2. Specifically, $\left\{(N_n^1=1,N_n^2=0,{\xi }_n=2)\right\}$ can occur under our policy. Once buffer 1 becomes empty, service priority is given to buffer 2. Furthermore, there is no transition from the state $\left\{(N_n^1=1,N_n^2=j,{\xi }_n=2)\right\}$ (where $j>=1$) to any state where $N_{n+1}^1=0$. Next, we define the matrices $B_i$ for $1\le i\le L-1$, which requires $L>1$.

$$\begin{array}{c}\hfill B_i=\left(\begin{array}{ccccccccccc}0& a_{i,0}& 0& a_{i,1}& 0& a_{i,2}& \cdots & 0& a_{i,K_2-1}& 0& a_{i,\overline{K_2}}\\ 0& a_{i,0}& 0& a_{i,1}& 0& a_{i,2}& \cdots & 0& a_{i,K_2-1}& 0& a_{i,\overline{K_2}}\\ 0& 0& 0& a_{i,0}& 0& a_{i,1}& \cdots & 0& a_{i,K_2-2}& 0& a_{i,\overline{K_2-1}}\\ 0& a_{i-1,0}& 0& a_{i-1,1}& 0& a_{i-1,2}& \cdots & 0& a_{i-1,K_2-1}& 0& a_{i-1,\overline{K_2}}\\ 0& 0& 0& 0& 0& a_{i,0}& \cdots & 0& a_{i,K_2-3}& 0& a_{i,\overline{K_2-2}}\\ 0& 0& 0& a_{i-1,0}& 0& a_{i-1,1}& \cdots & 0& a_{i-1,K_2-2}& 0& a_{i-1,\overline{K_2-1}}\\ ⋮& ⋮& ⋮& ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& ⋮\\ 0& 0& 0& 0& 0& 0& \cdots & 0& a_{i,0}& 0& a_{i,\overline{1}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& a_{i-1,1}& 0& a_{i-1,\overline{2}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& a_{i,\overline{0}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& a_{i-1,0}& 0& a_{i-1,\overline{1}}\end{array}\right),1\le i\le L-1,\mathrm{for}L>1.\end{array}$$

(8)

This case corresponds to when the queue length of buffer 1 is below the threshold L. In this scenario, the existing service priority is maintained; for instance, if buffer 2 had priority at the nth departure, it retains it. Note that if $L=1$, this range is empty and no such matrices are defined. Next, for the range $L\le i\le K_1-1$ (where $L\ge 1$), let us define the matrix $B_i$ as follows:

$$\begin{array}{c}\hfill B_i=\left(\begin{array}{ccccccccccc}{a}_{i,0}& 0& a_{i,1}& 0& a_{i,2}& 0& \cdots & a_{i,K_2-1}& 0& a_{i,\overline{K_2}}& 0\\ a_{i,0}& 0& a_{i,1}& 0& a_{i,2}& 0& \cdots & a_{i,K_2-1}& 0& a_{i,\overline{K_2}}& 0\\ 0& 0& a_{i,0}& 0& a_{i,1}& 0& \cdots & a_{i,K_2-2}& 0& a_{i,\overline{K_2-1}}& 0\\ a_{i-1,0}& 0& a_{i-1,1}& 0& a_{i-1,2}& 0& \cdots & a_{i-1,K_2-1}& 0& a_{i-1,\overline{K_2}}& 0\\ 0& 0& 0& 0& a_{i,0}& 0& \cdots & a_{i,K_2-3}& 0& a_{i,\overline{K_2-2}}& 0\\ 0& 0& a_{i-1,0}& 0& a_{i-1,1}& 0& \cdots & a_{i-1,K_2-2}& 0& a_{i-1,\overline{K_2-1}}& 0\\ ⋮& ⋮& ⋮& ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& ⋮\\ 0& 0& 0& 0& 0& 0& \cdots & a_{i,0}& 0& a_{i,\overline{1}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & a_{i-1,1}& 0& a_{i-1,\overline{2}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& a_{i,\overline{0}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & a_{i-1,0}& 0& a_{i-1,\overline{1}}& 0\end{array}\right),L\le i\le K_1-1,\mathrm{for}L\ge 1.\end{array}$$

(9)

The matrix $B_i$ for the range $L\le i\le K_1-1$ (where $L\ge 1$) represents transitions where the queue length of buffer 1 is at least L at the $(n+1)$th departure. Consequently, the service priority of buffer 1 is maintained, or the service priority is switched from buffer 2 to buffer 1.

The matrix $C_0$ represents the transitions where the queue length of buffer 1 decreases from 2 to 1, which corresponds to a service completion at buffer 1. For this transition to occur, buffer 1 must have service priority. Specifically, there is no state transition from $\left\{(N_n^1=2,N_n^2=j,{\xi }_n=2)\right\}$(where $j\ge 1$) to $\left\{(N_{n+1}^1=1,N_{n+1}^2,{\xi }_{n+1})\right\}$.

$$\begin{array}{c}\hfill C_0=\left(\begin{array}{ccccccccccc}{a}_{0,0}& 0& a_{0,1}& 0& a_{0,2}& 0& \cdots & a_{0,K_2-1}& 0& a_{0,\overline{K_2}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& a_{0,0}& 0& a_{0,1}& 0& \cdots & a_{0,K_2-2}& 0& a_{0,\overline{K_2-1}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& 0& a_{0,0}& 0& \cdots & a_{0,K_2-3}& 0& a_{0,\overline{K_2-2}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ ⋮& ⋮& ⋮& ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& ⋮\\ 0& 0& 0& 0& 0& 0& \cdots & a_{0,0}& 0& a_{0,\overline{1}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& a_{0,\overline{0}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\end{array}\right).\end{array}$$

(10)

The definition of the matrix $C_i$ is split into two cases based on the threshold L. First, for the range $1\le i\le L-2$ (which requires $L>2$), this represents state transitions where the service priority remains unchanged. Because the resulting queue length of buffer 1 (i) is below the threshold L, the existing service priority is maintained. For example, if a non-empty buffer 2 had service priority, it will keep it.

$$\begin{array}{c}\hfill C_i=\left(\begin{array}{ccccccccccc}{a}_{i,0}& 0& a_{i,1}& 0& a_{i,2}& 0& \cdots & a_{i,K_2-1}& 0& a_{i,\overline{K_2}}& 0\\ 0& a_{i,0}& 0& a_{i,1}& 0& a_{i,2}& \cdots & 0& a_{i,K_2-1}& 0& a_{i,\overline{K_2}}\\ 0& 0& a_{i,0}& 0& a_{i,1}& 0& \cdots & a_{i,K_2-2}& 0& a_{i,\overline{K_2-1}}& 0\\ 0& a_{i-1,0}& 0& a_{i-1,1}& 0& a_{i-1,2}& \cdots & 0& a_{i-1,K_2-1}& 0& a_{i-1,\overline{K_2}}\\ 0& 0& 0& 0& a_{i,0}& 0& \cdots & a_{i,K_2-3}& 0& a_{i,\overline{K_2-2}}& 0\\ 0& 0& 0& a_{i-1,0}& 0& a_{i-1,1}& \cdots & 0& a_{i-1,K_2-2}& 0& a_{i-1,\overline{K_2-1}}\\ ⋮& ⋮& ⋮& ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& ⋮\\ 0& 0& 0& 0& 0& 0& \cdots & a_{i,0}& 0& a_{i,\overline{1}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& a_{i-1,1}& 0& a_{i-1,\overline{2}}\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& a_{i,\overline{0}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& a_{i-1,0}& 0& a_{i-1,\overline{1}}\end{array}\right),1\le i\le L-2,\mathrm{for}L>2.\end{array}$$

(11)

Next, for the remaining range $L-1\le i\le K_1-1$ (where $L\ge 2$), we define the matrix $C_i$ as follows:

$$\begin{array}{c}\hfill C_i=\left(\begin{array}{ccccccccccc}{a}_{i,0}& 0& a_{i,1}& 0& a_{i,2}& 0& \cdots & a_{i,K_2-1}& 0& a_{i,\overline{K_2}}& 0\\ a_{i,0}& 0& a_{i,1}& 0& a_{i,2}& 0& \cdots & a_{i,K_2-1}& 0& a_{i,\overline{K_2}}& 0\\ 0& 0& a_{i,0}& 0& a_{i,1}& 0& \cdots & a_{i,K_2-2}& 0& a_{i,\overline{K_2-1}}& 0\\ a_{i-1,0}& 0& a_{i-1,1}& 0& a_{i-1,2}& 0& \cdots & a_{i-1,K_2-1}& 0& a_{i-1,\overline{K_2}}& 0\\ 0& 0& 0& 0& a_{i,0}& 0& \cdots & a_{i,K_2-3}& 0& a_{i,\overline{K_2-2}}& 0\\ 0& 0& a_{i-1,0}& 0& a_{i-1,1}& 0& \cdots & a_{i-1,K_2-2}& 0& a_{i-1,\overline{K_2-1}}& 0\\ ⋮& ⋮& ⋮& ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& ⋮\\ 0& 0& 0& 0& 0& 0& \cdots & a_{i,0}& 0& a_{i,\overline{1}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & a_{i-1,1}& 0& a_{i-1,\overline{2}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& a_{i,\overline{0}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & a_{i-1,0}& 0& a_{i-1,\overline{1}}& 0\end{array}\right),L-1\le i\le K_1-1,\mathrm{for}L\ge 2.\end{array}$$

(12)

The matrix $C_i$ in this range represents transitions where the queue length of buffer 1 reach L before $(n+1)$th departure. This means the priority is either maintained at buffer 1 or transferred from buffer 2; in this scenario, priority is never assigned to buffer 2.

$$\begin{array}{c}\hfill D_i=\left(\begin{array}{ccccccccccc}{a}_{i,0}& 0& a_{i,1}& 0& a_{i,2}& 0& \cdots & a_{i,K_2-1}& 0& a_{i,\overline{K_2}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& a_{i,0}& 0& a_{i,1}& 0& \cdots & a_{i,K_2-2}& 0& a_{i,\overline{K_2-1}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& 0& a_{i,0}& 0& \cdots & a_{i,K_2-3}& 0& a_{i,\overline{K_2-2}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ ⋮& ⋮& ⋮& ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& ⋮\\ 0& 0& 0& 0& 0& 0& \cdots & a_{i,0}& 0& a_{i,\overline{1}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& a_{i,\overline{0}}& 0\\ 0& 0& 0& 0& 0& 0& \cdots & 0& 0& 0& 0\end{array}\right),0\le i\le K_1-L.\end{array}$$

(13)

The matrix $D_i$ represents state transitions where buffer 1 maintains its service priority from the nth to the $(n+1)$th departure epoch. This occurs specifically when the queue length of buffer 1 is greater than or equal to the threshold L, a condition that prevents service priority from being given to buffer 2. Subsequently, the transition probability matrix $\overline{Q}$ of the Markov chain $\{(N_n^1,N_n^2,{\xi }_n),n\ge 0\}$ is given by

$$\begin{array}{c}\hfill \overline{Q}=\left(\begin{array}{ccccccccccc}{A}_0& A_1& A_2& \cdots & A_{L-1}& A_L& A_{L+1}& \cdots & A_{K_1-2}& A_{K_1-1}& {\overline{A}}_{K_1}\\ B_0& B_1& B_2& \cdots & B_{L-1}& B_L& B_{L+1}& \cdots & B_{K_1-2}& B_{K_1-1}& {\overline{B}}_{K_1}\\ 0& C_0& C_1& \cdots & C_{L-2}& C_{L-1}& C_L& \cdots & C_{K_1-3}& C_{K_1-2}& {\overline{C}}_{K_1-1}\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮\\ 0& 0& 0& \cdots & C_1& C_2& C_3& \cdots & C_{K_1-L}& C_{K_1-L+1}& {\overline{C}}_{K_1-L+2}\\ 0& 0& 0& \cdots & D_0& D_1& D_2& \cdots & D_{K_1-L-1}& D_{K_1-L}& {\overline{D}}_{K_1-L+1}\\ 0& 0& 0& \cdots & 0& D_0& D_1& \cdots & D_{K_1-L-2}& D_{K_1-L-1}& {\overline{D}}_{K_1-L}\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮& \ddots & ⋮& ⋮& ⋮\\ 0& 0& 0& \cdots & 0& 0& 0& \cdots & D_1& D_2& {\overline{D}}_3\\ 0& 0& 0& \cdots & 0& 0& 0& \cdots & D_0& D_1& {\overline{D}}_2\\ 0& 0& 0& \cdots & 0& 0& 0& \cdots & 0& D_0& {\overline{D}}_1\end{array}\right).\end{array}$$

(14)

The submatrices in the last column of matrix $\overline{Q}$, such as ${\overline{A}}_{K_1}$, are matrices where the elements $a_{ij}$ are replaced by $a_{\overline{i},j}$, and the elements $a_{i,\overline{j}}$ are replaced by $a_{\overline{i},\overline{j}}$. Since the system has a finite number of states and satisfies irreducibility and aperiodicity conditions, the embedded Markov chain is ergodic. Moreover, because both buffers have finite capacity, the Markov chain is positive recurrent and stable by construction. Finally, the steady-state probability vector $\mathbf{x}$ of the Markov chain $\{(N_n^1,N_n^2,{\xi }_n),n\ge 0\}$ is obtained by solving the following equation:

$$\mathbf{x}\overline{Q}=\mathbf{x},\mathbf{x}\mathbf{e}=1,$$

(15)

where $\mathbf{e}={(1,1,\cdots ,1)}^T$.

3.2.2. Queue Length Distribution at an Arbitrary Time

In this section, we derive the probability distribution of the queue length at an arbitrary time. Let $N_1\left(t\right)$ and $N_2\left(t\right)$ be the queue lengths in buffers 1 and 2 at time t, respectively.

$$b\left(t\right)=\left\{\begin{array}{c}0,\mathrm{if}\mathrm{the}\mathrm{server}\mathrm{is}\mathrm{idle}\mathrm{at}\mathrm{time}t,\hfill \\ 1,\mathrm{if}\mathrm{the}\mathrm{server}\mathrm{is}\mathrm{busy}\mathrm{at}\mathrm{time}t.\hfill \end{array}\right.$$

Definition of stationary probabilities

$$\begin{array}{c}\hfill y_0=\underset{t\to \infty }{\lim }\mathrm{Pr}\{b\left(t\right)=0\},\end{array}$$

(16)

$$\begin{array}{c}\hfill y_n^r=\underset{t\to \infty }{\lim }\mathrm{Pr}\{N_r\left(t\right)=n,b\left(t\right)=1\},r=1,2.\end{array}$$

(17)

First, we derive the probability $y_0$ that a server is idle. Since the system is work-conserving, this probability is independent of the service discipline, allowing us to analyze the simpler first-come, first-served (FCFS) case. Our analysis is based on constructing an underlying renewal process, where the renewal points are defined as the epochs at which an idle period begins. By applying the key renewal theorem to this process, we obtain the long-run probability of the server being idle:

$$y_0={\displaystyle \frac{{\int }_0^{\infty }P\left\{\mathrm{no}\mathrm{arrivals}\mathrm{during}(0,x]\right\}dx}{E\left[X\right]}}={\displaystyle \frac{{\int }_0^{\infty }{e}^{-({\lambda }_1+{\lambda }_2)x}dx}{E\left[X\right]}}.$$

(18)

The mean length of a renewal cycle, $E\left[X\right]$, can be derived using the methodology established in [28]. This approach yields $E\left[X\right]=E·{x_{0,0,2}}^{-1}$, where E is the mean inter-departure time of customers and ${x_{0,0,2}}^{-1}$ represents the mean number of departures in one renewal cycle. Substituting these terms into (18) gives

$$y_0={\displaystyle \frac{1}{E·{x_{0,0,2}}^{-1}}}·{\displaystyle \frac{1}{{\lambda }_1+{\lambda }_2}}.$$

(19)

By substituting the expression for $E=x_{0,0,2}\left(\frac{1}{{\lambda }_1+{\lambda }_2}+\mu \right)+(1-x_{0,0,2})\mu$ = $\frac{x_{0,0,2}+({\lambda }_1+{\lambda }_2)\mu }{{\lambda }_1+{\lambda }_2}$, we obtain the final expression for the idle probability:

$$y_0={\displaystyle \frac{x_{0,0,2}}{x_{0,0,2}+({\lambda }_1+{\lambda }_2)\mu }}.$$

(20)

Therefore, the probability that the server is idle, $P_{\mathrm{idle}}$, and the probability that the server is busy, $P_{\mathrm{busy}}$, are given by

$$\begin{array}{c}\hfill P_{\mathrm{idle}}=y_0,\end{array}$$

(21)

$$\begin{array}{c}\hfill P_{\mathrm{busy}}=1-P_{\mathrm{idle}}={\displaystyle \frac{\mu }{E}}.\end{array}$$

(22)

Next, we derive the marginal queue length probabilities $y_n^1(n\ge 1)$ of buffer 1 at an arbitrary time. To do this, we use the supplementary variable method. Let $\tilde{T}\left(\widehat{T}\right)$ be the elapsed and remaining service times of the customers in service, respectively. Furthermore, we define the stationary joint probability distribution of the queue length and remaining service time as:

$${\alpha }_n\left(x\right)dx=\underset{t\to \infty }{\lim }\mathrm{Pr}\{N_1\left(t\right)=n,b\left(t\right)=1,x<\widehat{T}\le x+dx\}.$$

(23)

We define the Laplace transform of ${\alpha }_n\left(x\right)$ as:

$${\alpha }_n^{*}\left(s\right)={\int }_0^{\infty }{e}^{-sx}{\alpha }_n\left(x\right)dx.$$

(24)

To derive the queue length distribution at an arbitrary time, we must account for the number of customer arrivals during the elapsed service time. Therefore, we define the conditional probability ${\beta }_n\left(x\right)$ as

$$\begin{array}{c}\hfill {\beta }_n\left(x\right)dx=\underset{t\to \infty }{\lim }\mathrm{Pr}\{n\mathrm{arrivals}\mathrm{of}\mathrm{type}\text{-}1\mathrm{customers}\mathrm{during}\tilde{T},\\ \hfill x<\widehat{T}\le x+dx,b\left(t\right)=1\},\end{array}$$

(25)

We also define the Laplace transform ${\beta }_n^{*}\left(s\right)$ of ${\beta }_n\left(x\right)$ as

$${\beta }_n^{*}\left(s\right)={\int }_0^{\infty }{e}^{-sx}{\beta }_n\left(x\right)dx.$$

(26)

By conditioning the queue length at the last service completion epoch before an arbitrary time t, ${\alpha }_n^{*}\left(s\right)$ satisfies the following equations: For $0\le n<K_1$

$$\begin{array}{cc}\hfill {\alpha }_n^{*}\left(s\right)& ={\displaystyle \frac{\mu }{E}}\left[x_{0,0,2}{\beta }_n^{*}\left(s\right)+\sum _{l=0}^{K_2}\sum _{k=1}^{n+1}{x}_{k,l,1}{\beta }_{n-k+1}^{*}\left(s\right)\right.\hfill \\ \hfill & \left.+\sum _{k=0}^{\min \{n,L-1\}}{x}_{k,l,2}{\beta }_{n-k}^{*}\left(s\right)\right].\hfill \end{array}$$

(27)

By applying the method presented in [29], ${\beta }_n^{*}\left(s\right)$ is obtained as follows:

$${\beta }_n^{*}\left(s\right)={\displaystyle \frac{1}{\mu }}\left[\sum _{k=0}^n{a}_{k\overline{0}}{R}_{n-k}\left(s\right)-G^{*}\left(s\right)R_n\left(s\right)\right],$$

(28)

where $R_n\left(s\right)={(s-{\lambda }_1)}^{-1}{\left\{-{\lambda }_1{(s-{\lambda }_1)}^{-1}\right\}}^n.$ Finally, substituting ${\beta }_n^{*}\left(s\right)$ into the above equations, and setting $s=0$, we obtain the stationary marginal queue length probabilities $y_n^1$ at an arbitrary time. For $0\le n<K_1$

$$\begin{array}{cc}\hfill y_n^1& ={\displaystyle \frac{1}{{\lambda }_{1}E}}\left[x_{0,0,2}\left\{1-\sum _{m=0}^n{a}_{m\overline{0}}\right\}+\sum _{l=0}^{K_2}\sum _{k=1}^{n+1}{x}_{k,l,1}\left\{1-\sum _{m=0}^{n-k+1}{a}_{m\overline{0}}\right\}\right.\hfill \\ \hfill & \left.+\sum _{l=1}^{K_2}\sum _{k=0}^{\min \{n,L-1\}}{x}_{k,l,2}\left\{1-\sum _{m=0}^{n-k}{a}_{m\overline{0}}\right\}\right],\hfill \end{array}$$

(29)

and

$$y_{K_1}^1=P_{\mathrm{busy}}-\sum _{n=0}^{K_1-1}{y}_n^1.$$

Using a method similar to the previous case, we obtain the marginal queue length probabilities $y_n^2$ of buffer 2 at an arbitrary time: For $0\le n<K_2,$

$$\begin{array}{cc}\hfill y_n^2& ={\displaystyle \frac{1}{{\lambda }_{2}E}}\left[x_{0,0,2}\left\{1-\sum _{m=0}^n{a}_{\overline{0}m}\right\}+\sum _{k=0}^{L-1}\sum _{l=1}^{n+1}{x}_{k,l,2}\left\{1-\sum _{m=0}^{n-l+1}{a}_{\overline{0}m}\right\}\right.\hfill \\ \hfill & \left.+\sum _{k=1}^{K_1}\sum _{l=0}^n{x}_{k,l,1}\left\{1-\sum _{m=0}^{n-l}{a}_{\overline{0}m}\right\}\right],\hfill \end{array}$$

(30)

and

$$\begin{array}{c}\hfill y_{K_2}^2=1-\sum _{n=0}^{K_2-1}{y}_n^2-y_0.\end{array}$$

(31)

3.2.3. Performance Measures

Using the stationary queue length distribution $\{y_n,n\ge 0\}$, we derive the following performance measures:

• Loss probability $P_{\mathrm{loss}}^i$ of buffer $i(i=1,2)$:

  $$\begin{array}{c}\hfill P_{\mathrm{loss}}^i=y_{K_i}^i,i=1,2.\end{array}$$

  (32)
• Mean queue length of buffer $i(i=1,2)$:

  $$\begin{array}{c}\hfill M_i=\sum _{n=0}^{K_i}n{y}_n^i.\end{array}$$

  (33)
• Mean waiting time in buffer $i(i=1,2)$, obtained by applying Little’s Law:

  $$\begin{array}{c}\hfill W_i={\displaystyle \frac{M_i}{{\lambda }_i(1-P_{\mathrm{loss}}^i)}}.\end{array}$$

  (34)

4. Numerical Results

In the numerical example, we examine changes in key performance indicators—delay time and blocking probability—by varying the offered load, threshold value, and service time distributions. The coefficients of variation (CV) for these distributions range from 0.3 to 1.4.

Table 1. Settings for Service Time Distributions and System Parameters.

Category	Description
Service Time Distributions	All service time distributions have a mean of 10 but differ in CV: Uniform(5, 15) with CV = 0.3; Exponential distribution with rate = 0.1 (CV = 1.0); Gamma distribution with a shape parameter of 0.44 and a scale parameter of 22.52 (CV = 1.4).
Arrival Rate per Class	Arrival rates for each class range from 0.01 to 0.06.
Class 1 Buffer Size	Buffer sizes range from 5 to 25 in increments of 5. The threshold is set as a proportion of the buffer size, with ratios ranging from 0.2 to 1.0. For example, if the buffer size is 5 and the ratio is 0.2, the threshold is 1.
Class 2 Buffer Size	Buffer sizes range from 10 to 40 in increments of 10.

summarizes the conditions used in the experimental setup.

All numerical results are computed by solving the steady-state Equation (15) using direct linear algebra methods. We reformulate the system as $({\overline{Q}}^T-I){\mathbf{x}}^T=\mathbf{0}$ with normalization constraint $\mathbf{x}\mathbf{e}=1$, replace the last row of $({\overline{Q}}^T-I)$ to form a non-singular system, and solve using numpy.linalg.solve in Python 3.12.4 with NumPy 2.3.0. This direct method provides solutions accurate to machine precision without iterative procedures and is computationally efficient for our parameter ranges ($K_1\le 25$, $K_2\le 40$).

The computational complexity is $O\left(n^3\right)$ for LU decomposition, where $n=2(K_1+1)$$(K_2+1)$ is the state space size. For our experiments, $n\approx 2100$, making direct methods well-suited for this problem size. The transition matrix $\overline{Q}$ has a sparse block-tridiagonal structure that reduces memory requirements from $O\left(n^2\right)$ to $O\left(n{K}_2\right)$ when using sparse storage formats. For larger systems, iterative methods or exploiting the block structure could further improve efficiency.

First, we examined the performance of a system with threshold-based priority control and compared it with the conventional two-class system without control. To explore scenarios with an effective offered load exceeding 0.9, we set the arrival rate for customers in both classes to 0.05. Comprehensive experiments were conducted across all combinations of buffer sizes 1 and 2, and the corresponding data on the threshold ratio were collected. The threshold ratio represents the fraction of buffer 1’s full capacity that determines the switching point of service priority. For instance, a threshold ratio of 0.3 means that when the queue length of buffer 1 reaches 30% of its capacity, the service priority switches from buffer 2 to buffer 1. Thus, smaller threshold ratios facilitate easier priority access for class 1 customers, while larger ratios let class 2 be served more frequently. Figure 1 shows the waiting times for the three probability distributions, each evaluated for systems with and without priority control. The ‘No Control’ case represents the system without threshold-based priority control. In this policy, customers from class 1 and class 2 are served strictly in the order of their arrivals, regardless of their class. The variance in waiting times is considerably high when ‘No Control’ policy is applied. When the threshold value is low, making it easier for class 1 customers to gain access to service priority, both the mean and variance of waiting times are lower compared to the ‘No Control’ case. A noteworthy finding is that threshold-based control substantially reduces not only the mean but also the variance of waiting times for class 1. This variance reduction has important practical implications: it enables more reliable SLA compliance and better quality-of-experience for delay-sensitive applications, as extreme delays become rare.

Figure 2a,b show how waiting times change with load levels and service time distributions under the threshold-based priority control. In general, service time distributions with larger CVs result in longer waiting times. When the system load is low, the choice of distribution significantly impacts the waiting times. However, when the load exceeds 0.6, the differences between distributions become relatively minor. In addition, the number of outliers for class 2 customers increases as the load level rises. Two counterintuitive phenomena emerge from these results. First, the impact of service time variability (CV) diminishes at high system loads. At low loads, the uniform distribution (CV = 0.3) yields substantially shorter waiting times than the gamma distribution (CV = 1.4). However, at high loads, the three distributions converge to similar performance. This suggests that in heavily loaded systems, the common assumption of exponential service times may be a reasonable approximation, simplifying analysis without significant loss of accuracy. Second, class 2 customers exhibit increasing tail volatility as load rises, evidenced by growing numbers of outliers. This implies that while mean waiting time provides a useful summary statistic, percentile-based SLAs may be violated more frequently for class 2 under high load, even when mean performance appears acceptable.

Figure 3a–c demonstrate that the waiting times for both classes increase with higher load and threshold ratios. In particular, the waiting time for Class 2 increases substantially, indicating a heightened sensitivity to system load. Small increases in threshold ratio moderately affect class 1 but severely degrade class 2 performance. Consequently, threshold selection requires careful consideration of class 2 tolerance limits rather than simply optimizing class 1 performance. Furthermore, in the high loading range, class 2 waiting times exhibit near-exponential growth with the threshold ratio, suggesting a critical region beyond which class 2 service becomes severely compromised.

Let us examine the trend in blocking probability. Figure 4a–d show the blocking probability of classes 1 and 2 under three service time distributions and varying loading levels. These figures present two cases where the threshold ratio is 0.2 and 0.8, with the buffer size for class 2 fixed at 20. The threshold ratio represents the proportion used to determine the threshold value relative to the size of buffer 1. Consistently, we observe that higher CV values lead to increased blocking probabilities, which aligns with the trends seen in mean waiting times. As the threshold ratio increases, the blocking probability for class 1 customers increases because a greater number of customers must arrive before the service begins. Conversely, for class 2 customers, the blocking probability decreases as the threshold ratio increases because higher threshold ratios make it more likely that service priority will be allocated to buffer 2.

5. Conclusions

We present a comprehensive analysis of a Markovian queueing model with two finite buffers and an alternating server operating under a queue-length-based threshold-switching policy. By formulating the system as an embedded Markov chain and applying supplementary variable methods, we derived steady-state distributions and key performance metrics, including blocking probabilities and average queue lengths for both customer types. Our results highlight that threshold-based control policies can effectively balance service priorities, preventing excessive delays for high-priority customers, while maintaining acceptable performance for lower-priority traffic. The model’s flexibility allows it to be adapted to various real-world applications, particularly differentiated service provision in telecommunications and dynamic resource allocation in cloud computing and healthcare.

Future research may extend this framework to more general arrival and service processes, including differentiated service time distributions for each customer class, incorporate additional priority classes, or optimize the threshold values for specific performance objectives. Considering the complexity introduced by distinct service time distributions, its rigorous analysis is left as a promising direction for future work. For systems with significantly larger buffer capacities (e.g., $K_1,K_2>100$), developing specialized numerical methods that exploit the block-tridiagonal structure of the transition matrix or employing iterative solution techniques could improve computational efficiency. While our exact analytical approach is well-suited for centralized threshold control with known parameters, we acknowledge that distributed systems with strategic users may benefit from complementary approaches such as game theory or machine learning.