Intelligent Task Distribution Using Hybrid Algorithms and Enhancing Performance by Integrating FRLB and PBLB

Abstract

In modern computing environments characterized by high variability and complex workloads, traditional load-balancing algorithms such as Round Robin and Least Connections are often found to be less effective in distributing tasks and maintaining optimal performance. In this paper, a hybrid load-balancing algorithm is proposed, where the strengths of Fastest Response Load Balancing (FRLB) and Priority-Based Load Balancing (PBLB) are combined. Through this adaptive approach, response times are minimized and load distribution across heterogeneous server environments is balanced more effectively. In the recent literature, the need for enhanced load-balancing solutions that can adapt to dynamic conditions in cloud computing, IoT, and large-scale web services has been increasingly emphasized. By integrating a hybrid mechanism, a robust solution is provided by the hybrid algorithm, which is designed to merge between FRLB and PBLB. As demonstrated through simulations, a noticeable improvement in performance is achieved, with a significant reduction in average response time when compared to FRLB and PBLB. The proposed algorithm outperforms the classical FRLB and PBLB.

1. Introduction

In today’s interconnected world, where websites and applications are expected to be available continuously with minimal interruption, the concept of network load balancing has become increasingly crucial. Network load balancing is a technique used to distribute incoming network traffic across multiple servers or resources to ensure optimal utilization of resources, maximize throughput, minimize response time, and avoid overloading any single server. This technique plays a critical role in enhancing the scalability, availability, and reliability of networks.

Network load balancing involves the efficient distribution of incoming network traffic across a cluster of servers or resources to prevent any single server from becoming a bottleneck. It ensures that no individual server is overwhelmed with requests, thereby maintaining smooth operation and optimal performance. This distribution of traffic can be based on various factors such as server capacity, current workload, or predefined algorithms [1].

Several components are involved in load balancing. The load balancer is the central component responsible for distributing incoming traffic across multiple servers or resources. It acts as a virtual point of entry for clients and forwards requests to the appropriate backend servers. Backend servers process the incoming requests and host the applications or services being accessed by clients [2].

Load balancers employ various algorithms to determine how incoming traffic should be distributed among backend servers. Some common algorithms include Round Robin, Least Connections, Weighted Round Robin, etc. Some types of load-balancing algorithm outperform other types. In this context, load balancing can be implemented in various network architectures, such as Web Servers, Application Servers, and Database Servers.

The limitations of conventional load-balancing methods necessitate the development of more sophisticated and adaptive solutions, considering various factors such as server capacities, current loads, response times, and task priorities. This dynamic approach can significantly improve load distribution and system performance. This work proposes a hybrid load-balancing algorithm that integrates the strengths of FRLB and PBLB. The hybrid algorithm leverages real-time data to dynamically adjust the priorities of several servers for incoming requests. By combining traditional load-balancing principles of FRLP and PBLB, this approach aims to minimize the response times of servers. The proposed algorithm addresses the need for more adaptive and efficient load-balancing solutions and enhances the performance of current algorithms.

The remaining of this work is organized as follows: part II presents the literature review and related work, part III presents the proposed algorithms, part IV is the discussion and analysis, and part V is the conclusion.

2. Literature Review

Several algorithms have been designed and developed in load balancing to improve the performance of networks. This section provides a literature review about enhancements in algorithms of load balancing.

Hagiwara et al. [1] propose a weighted load-balancing method to improve the responsiveness in clusters with nonuniform computational performance for heterogeneous clusters on hybrid clouds; the proposed method is effective in improving the average response time by 20%, the maximum response time by about 45%, and the response time variance by about 70%. Fahim et al. [2] propose an improvement in load balancing using a hybrid algorithm that considers the current load of the virtual machine of a data center and the status of its tasks during execution; the hybrid algorithm allows cloud service providers to improve the performance and availability and maximize the use of virtual machines (VMs) in their data centers. Özcan and Ş. Bora [3] propose a hybrid model of a three-level load-balancing architecture for Multi-Agent Systems (MASs) to provide load balancing on each host and agent, where each host has a load-balancing coordinator (LBC) to monitor the states of agents’ load and message traffic, and load balancing is guaranteed when load imbalance occurs in the system because LBCs decide appropriate solution levels. Chen et al. [4] propose a hybrid dynamic load-balancing algorithm for packet services, benefiting from the triangle module fusion method, simulation results show that the proposed algorithm can effectively decrease the blocking probabilities of hot-spot cells as well as the overall heterogeneous system. Shi et al. [5] propose a hybrid scheduling strategy, which is based on static allocation, and use a dynamic scheduling system with consideration of all factors in the process of load balancing; the proposed method can improve the utilization of the processor, and the simulation result indicates that the algorithm could improve the performance of parallel computing effectively when tested in the land surface disaster and ecology model. Marbukh [6] is working on the potential risks/benefits of natural two-tier hybrid load-balancing strategies by employing quasi-static load balancing, when divergence between the actual and expected exogenous conditions is indicated, a natural dynamic load balancing is employed, and the proposed algorithm inherits the local instability risk of dynamic load balancing. Bagwaiya and Raghuwanshi [7] propose a hybrid approach for load balancing using Throttled and Equally Spread Current Execution (ESCE) algorithms; the proposed algorithm properly manages the resources of the service contributor on the cloud’s server. Domanal and Reddy [8] propose a hybrid scheduling algorithm for load balancing in a distributed environment by combining the methodology of Divide-and-Conquer and Throttled algorithms, and the proposed algorithm enhances the efficiency in both Cloud Sim and customized environments. It utilizes Virtual Machines more efficiently while reducing the execution time of the tasks allocated to Request Handlers (RHs) by 9.972% in comparison to the Modified Throttled algorithm. Harbin et al. [9] design an experimental testbed using a POX Software (jar standard) Defined Networks (SDN) controller and Mininet to analyze the performance of ML algorithms over heuristic ones, and the simulation results confirm that the ML algorithms are better in terms of packet loss and response time. Todorov et al. [10] propose a model which aims to reduce overall load and bandwidth and improve the routing mechanism on the SDN networks, by combining a segment routing algorithm and load-balancing mechanisms based on machine learning; the proposed model enhances the overall load on the network, reducing the bandwidth. Doke and Sangeeta [11] apply deep reinforcement learning for a network load balancer, which understands and adjusts continuously with the dynamic environment and optimizes the performance of the load balancer; the proposed algorithm optimizes the performance of the load balancer in terms of response time when dealing with big data. Arun Kumar et al. [12] propose an algorithm that enhances the end-to-end throughput in Cognitive Wireless Sensor Networks by exploiting available resources using ML techniques; the proposed algorithm improves energy efficiency by 62%.

The next section provides detailed information about the FRLB and PBLB algorithms where the proposed algorithm is based on them.

A. Fastest Response Load Balancing.

Fastest Response Load Balancing (FRLB) [13,14] is a technique used in distributed computing and networking to balance the load across multiple servers by directing incoming requests to the server with the fastest response time. FRLB aims to minimize response time and maximize throughput by efficiently distributing the workload.

The load balancer continuously monitors the response times of all servers in the pool. This can be done by periodically sending test requests or by analyzing historical response time data.

FRLB algorithms typically prioritize routing requests to the server with the lowest response time at any given moment. However, the specific implementation details, including whether they incorporate strategies like adjusting monitoring frequency based on traffic levels, can vary depending on the load balancer software or platform being used.

When a new request arrives, the load balancer selects the server with the fastest response time based on the monitoring data. The selection process can vary depending on the algorithm used. One common approach is to select the server with the lowest average response time over a recent period. Once the server with the fastest response time is identified, the load balancer forwards the incoming request to that server.

After routing the request, the load balancer may update its monitoring data to reflect the response time of the selected server for future load-balancing decisions. This feedback loop helps the load balancer adapt to changes in the system’s workload and server performance over time. Figure 1 represents the FRLB algorithm.

Figure 1. Fastest Response Load-balancing Algorithm.

Equation (1) finds the server i with the minimum response time Ri among all available servers [15].

$$Selected Server=\arg {min}_{i=1}^{n}Ri$$

(1)

where R_i is the minimum response time of i server among all available servers n.

And (2) calculates the average response time of a server over a period [13]:

$$Average Response Time={\displaystyle \frac{{\sum }_{j=1}^m{R}_i^{\left(j\right)}}{m}}$$

(2)

where $R_i^{\left(j\right)}$ is the response time of server i for the jth request, and m is the total number of requests used to calculate the average response time.

The average response time of previous transactions being the lowest implies it will not necessarily be the lowest for current transactions for several reasons: If previous transactions had the lowest response time, the current system state might be different due to varying workloads. If the system is currently overloaded, response times can increase significantly. A previously lightly loaded system with fast response times can become heavily loaded due to the flow of new transactions, leading to increased response times. The availability of resources (CPU, memory, I/O) can fluctuate; if more resources were available previously, the response times were lower. If those resources are now contended for by more processes, response times can increase. The length of queues in the system can affect response times. The complexity and nature of transactions can vary. And system configuration may change. Therefore, while historical response times can provide a useful benchmark, they do not guarantee future performance due to the dynamic nature of system loads and resource availability. And the average response time is expressed in (3) [16].

$$ART=k.{\displaystyle \frac{L.Q.C}{R.S}}$$

(3)

where L is the system load represented by the number of transactions multiplied by the average processing time per transaction; R is the availability of resources, which can be expressed as $TotalResources/UtilizedResources$; Q is the length of the queue—in other words it is the number of transactions in queue; C is the complexity of a transaction; S is the changes in system configuration; and K is a proportionality constant that normalizes the equation.

The response time of a user is typically calculated as the time it takes for a server to process a user’s request and send back a response. This response time includes several components:

Client-Side Processing Time ($T_{CSP}$), which is the time taken by the user’s device or browser to prepare and send the request to the server. This includes DNS resolution, establishing a connection, and sending the request payload.

Network Latency ($T_{NL}$), which is the time it takes for the request to travel from the user’s device to the server over the network. This includes factors such as physical distance, network congestion, and the quality of the network connection.

Server-Side Processing Time ($T_{SSP})$, which is the time taken by the server to receive, process, and generate a response to the request. This includes any application logic execution, database queries, or other operations necessary to fulfil the request.

Network Latency—Back ($T_{NLB}$), which is the time it takes for the response to travel from the server back to the user’s device over the network.

Client-Side Processing Time—Back ($T_{CSPB}$), which is the time taken by the user’s device or browser to receive and process the response. This includes parsing the response, rendering any content, and executing client-side scripts.

And Additional Traffic Processing Time ($T_{ATP}$), which is the time taken by the server to process the additional incoming requests, this includes the existing load, (which is the current load on the server before the additional traffic), the additional traffic, (which is the incoming requests that are part of the extra load), and the time taken by the server to process the additional incoming requests.

The overall response time experienced by the user is the sum of these individual components. Load balancers typically measure response time by tracking the time between when a request is received and when the corresponding response is sent out as shown in (4) [17]

$${RT}_{user}=T_{CSP}+T_{NL}+T_{SSP}+T_{NLB}+T_{CSPB}+T_{ATP}$$

(4)

B. Priority-Based Load Balancing.

Priority-based Load Balancing (PBLB) [18] is a technique where incoming requests are assigned priorities based on certain criteria, and these priorities are used to determine how requests are distributed among the available servers. This approach allows for more granular control over resource allocation, ensuring that high-priority tasks are handled promptly.

Each incoming request is assigned a priority value based on specific factors such as the type of request, user importance, or system requirements. These priorities could be predefined or dynamically determined based on real-time conditions.

Priority levels are assigned randomly for demonstration purposes, but in a real-world scenario, the priority assignment should be more meaningful and dynamic; the factors that could dynamically affect the priority assignment in a PBLB algorithm are the task type, service level agreements (SLAS), resource requirements, task deadline, current load, historical performance, and user priority [19].

Requests are placed in a priority queue based on their assigned priorities. The priority queue ensures that higher-priority requests are processed before lower-priority ones. When a server becomes available to process a request, the load balancer selects the next request from the priority queue. This selection process ensures that the highest priority request in the queue is processed first.

The criteria for load balancing can vary based on the priorities assigned to requests. For example, if the goal is to minimize the response time for high-priority requests, the load balancer may prioritize sending those requests to servers with the lowest current load or fastest response times. Figure 2 represents the algorithm of PBLB.

Figure 2. Priority-Based Load Balancing algorithm.

To select the next request based on maximum priority, the load balancer uses (5) [17].

$$Selected Request=\mathit{arg} {max}_{i=1}^{n}Pi$$

(5)

where P_i as the priority of request i.

To balance the load among servers based on priorities, various criteria can be used. For example, if the load balancer aims to minimize the response time for high-priority requests, it may select the server with the minimum response time using (1).

Starvation is a major drawback of PBLB; it occurs when low-priority tasks are continually deprived of resources because higher-priority tasks dominate the system. To prevent starvation, several strategies can be employed to ensure that all tasks receive fair processing time. Using the aging technique, where the priority of a task increases the longer it waits in the queue, this ensures that even low-priority tasks eventually gain enough priority to be processed. Using fair queuing algorithms that allocate resources in such a way that each task gets a fair share of the processing time, one approach is to use Weighted Round-Robin or Deficit Round-Robin scheduling. Ensuring that each server or queue receives a guaranteed minimum amount of service, this can be done by periodically processing low-priority tasks regardless of the presence of high-priority tasks and moving tasks between different priority queues based on their behavior and wait time; for example, if a task has been waiting too long in a low-priority queue, it can be moved to a higher-priority queue [20,21,22,23].

C. Comparison Between FRLB and PBLB.

Comparing FRLB and PBLB can help to understand their respective strengths, weaknesses, and suitability for different scenarios [13,24,25,26].

Table 1 summarizes the advantages and disadvantages of FRLB and PBLB.

Table 1. Pros and cons of FRLB and PBLB algorithms.

FRLB		PBLB
Pros.	Cons.	Pros.	Cons.
Minimized Response Time	Computational Overhead	Prioritization of Critical Tasks	Complexity
Efficient Resource Utilization	Complexity	Flexible Resource Allocation	Potential for Starvation
Adaptability	Potential for Inefficiency	Adaptability to Workload Dynamics	Increased Overhead
Improved Scalability	Dependency on Response Time Measurements	Customization and Control	Dependency on Priority Definitions

Table 2 focuses on the differences between both algorithms.

Table 2. COMPARISON BETWEEN FRLB AND PBLB.

Criteria	Comparison
Objective	FRLB focuses on minimizing response times, while PBLB focuses on prioritizing tasks based on specific criteria
Decision-Making Criteria	FRLB prioritizes servers based on response times, while PBLB prioritizes tasks based on assigned priorities
Resource Allocation	FRLB optimizes resource utilization based on server performance, while PBLB provides flexible resource allocation based on task priorities
Adaptability	Both FRLB and PBLB can adapt to changes in workload dynamics, but they do so based on different criteria (response times for FRLB and priorities for PBLB)

In general, FRLB is suitable for scenarios where minimizing response times is critical, such as real-time applications or services where low latency is essential, while PBLB is suitable for scenarios where tasks have varying levels of importance or urgency, such as processing critical transactions or serving high-value customers.

3. Proposed Algorithm

A hybrid FRLB–PBLB algorithm is designed to overcome the individual limitations of FRLB and PBLB by integrating their strengths into a unified, adaptive decision-making framework; the hybrid algorithm operates by jointly optimizing response time and load fairness while respecting request priorities, making it suitable for dynamic and heterogeneous environments such as cloud and distributed systems as shown in Figure 3.

Figure 3. Flowchart of the hybrid algorithm.

The steps of the flowchart are described in Algorithm 1.

Algorithm 1. Hybrid load balancing

Start 1.       Initialize servers (load, response time) 2.       For each incoming request: Extract request parameters:       - Priority       - Request size 3.       Identify available servers (load < max threshold) 4.       IF no server available:                     Reject or queue request 5.       FOR each available server i:           calculate FRLB term:                     R_fast(i) = current_response_time(i)           calculate PBLB term:                               Adjust based on priority:                                         IF High priority:                                                             Prefer low load servers                                                             R_bal(i) = load(i)                                          ELSE:                                                             Allow moderate load                                                             R_bal(i) = normalized load(i)           calculate Hybrid Score:                              Score(i) = α*R_fast(i) + (1-α)*R_bal(i) 6.       Select server with minimum Score(i) 7.       Assign request to selected server 8.       Update:       - Server load       - Response time 9.       Repeat for next request End

In the initialization phase, all servers are initialized with the current load $L_i$ and the estimated response time $R{T}_i$. A maximum load threshold $L_{\mathrm{m}\mathrm{a}\mathrm{x}}$ is defined to prevent overloading, and a weighting parameter $\alpha \in [0,1]$ is set to control the trade-off between response time and load balancing.

For each incoming request, the priority level (high, medium, or low) and request size are extracted. These attributes guide the decision-making process.

Server availability is checked by identifying all servers satisfying ($L_i<L_{\mathrm{m}\mathrm{a}\mathrm{x}}$); if no server is available, the request is either queued or rejected (depending on system policy).

For each available server, we calculate the expected response time and prioritize servers that can respond quickly ($R_{\mathrm{fast}}\left(i\right)=R{T}_i$), which represents the FRLB component (performance orientation).

Next, the PBLB component is considered (fairness and priority orientation), where the load-balancing term is calculated by considering both server load and request priority; for high-priority requests, the strong preference for lightly loaded servers ($R_{\mathrm{bal}}\left(i\right)=L_i$) is considered, while for low-priority requests, more flexibility is applied ($R_{\mathrm{bal}}\left(i\right)={\displaystyle \frac{L_i}{L_{\mathrm{m}\mathrm{a}\mathrm{x}}}}$). This ensures that critical tasks avoid congested servers, and lower-priority tasks help to maintain system balance.

During the hybrid decision function, the algorithm calculates a combined score for each server as shown in (6):

$$Score\left(i\right)=\alpha \cdot R_{\mathrm{fast}}\left(i\right)+(1-\alpha )\cdot R_{\mathrm{bal}}\left(i\right)$$

(6)

where α is a weight representing the relative importance of each component, R_fast is the fastest response time, and R_bal is the load balance time.

$\alpha$ controls the emphasis such that high $\alpha$ indicates performance-driven results, while low $\alpha$ indicates load-balancing driven results. R_bal is computed based on the factors of the current server loads, the expected impact of assigning a new request to each server, and deviation from the average load as shown in Equation (7).

$$R_{bal}=\gamma .{\displaystyle \frac{L_i}{\overline{L}}}+\delta$$

(7)

where $L_i$ is the load of server i, $\overline{L}$ is the average load across all servers, and γ, δ are scaling constants.

During the server selection process, the server of minimum score $\mathrm{m}\mathrm{i}\mathrm{n}Score\left(i\right)$ is selected. This ensures optimal trade-off between fast response, balanced load, and priority satisfaction. Once a server is selected, a request allocation and a system update are made, with server load ($L_i=L_i+\mathrm{request} \mathrm{size}$), and the response time is based on the updated load.

The process repeats for each incoming request, and the system continuously adapts to changing loads, varying priorities, and dynamic traffic patterns.

The hybrid algorithm ensures multi-objective optimization by simultaneous optimization of response time (FRLB), load distribution (PBLB), and priority handling. Dynamic adaptation is achieved by adjusting decisions based on the real-time system state, and it is suitable for non-static environments. Priority awareness is achieved by ensuring QoS for high-priority requests and preventing starvation through controlled flexibility. Tunable behavior by parameter $\alpha$ allows system-level control and optimization based on application requirements. Enhanced performance is achieved by avoiding overloading fastest servers (compared to FRLB) and reducing unnecessary delays (compared to PBLB), which result in lower average response time and better load distribution.

In PBLB, priorities are dynamically adjusted using real-time server and request parameters to better reflect the current system state. The process generally involves extracting real-time parameters (server current load, server response time, request type, and latency), computing the adjusted priority score based on (8), and selecting the server based on updated priority, then requests are matched with servers that have the best adjusted score match and provide timely responses.

$$Adjusted Priority=\lambda 1.Original Priority-\lambda 2.{\displaystyle \frac{L_i}{L_{max}}}+\lambda 3.(1-{\displaystyle \frac{R{T}_i}{R{T}_{max}}})$$

(8)

where $R{T}_i$ is the response time of server i, and λ1, λ2, and λ3 are tunable weights.

The hybrid FRLB–PBLB algorithm is fundamentally a balanced decision-making mechanism that integrates speed (FRLB) with fairness and priority control (PBLB). By combining these complementary strategies through a weighted model, it achieves robust, scalable, and adaptive load balancing, making it highly effective for modern distributed computing environments.

4. Results and Analysis

We simulate the proposed algorithms (Algorithm 1) and set the environmental requirements using MATLAB (R2020a) as shown in Table 3.

Table 3. Environmental settings.

Item	Value
Number of servers	20
Bandwidth limits for servers	100–1000 (Mbps)
Requests per second	10
Complexity levels of tasks	1–10
Priorities of tasks	1–5
Warm-up period	100 s

The following results are obtained:

Table 4 presents the response time and server load of the FRLB, PBLB, and hybrid algorithms. The consistency in response times and load across servers in the hybrid algorithm can be attributed to the balanced distribution of high- and low-priority tasks and fair scheduling mechanisms that prevent any single server from being overloaded.

Table 4. Results of response time and server load of FRLB, PBLB, and hybrid algorithms.

	Server Load (Unit)			Response Time (ms)
Server	FRLB	PBLB	Hybrid	FRLB	PBLB	Hybrid
1	25	265	142	0.699300699	0.37593985	3.846153846
2	25	13	83	1.19047619	7.142857143	3.846153846
3	25	13	58	1.694915254	7.142857143	3.846153846
4	25	13	13	7.142857143	7.142857143	3.846153846
5	25	13	13	7.142857143	7.142857143	3.846153846
6	25	13	13	7.142857143	7.142857143	3.846153846
7	25	13	13	7.142857143	7.142857143	3.846153846
8	25	13	13	7.142857143	7.142857143	3.846153846
9	25	12	13	7.142857143	7.692307692	3.846153846
10	25	12	13	7.142857143	7.692307692	3.846153846
11	25	12	13	7.142857143	7.692307692	3.846153846
12	25	12	13	7.142857143	7.692307692	3.846153846
13	25	12	13	7.142857143	7.692307692	3.846153846
14	25	12	13	7.142857143	7.692307692	3.846153846
15	25	12	13	7.142857143	7.692307692	3.846153846
16	25	12	13	7.142857143	7.692307692	3.846153846
17	25	12	12	7.692307692	7.692307692	3.846153846
18	25	12	12	7.692307692	7.692307692	3.846153846
19	25	12	10	7.692307692	7.692307692	3.846153846
20	25	12	10	7.692307692	7.692307692	3.846153846

Figure 4 illustrates the response time in visual form, while Figure 5 illustrates the server load in visual form.

Figure 4. Response time of FRLB, PBLB, and hybrid algorithms (ms).

Figure 5. Server load of FRLB, PBLB, and hybrid algorithms (ms).

FRLB is highly effective at minimizing response time because it always selects the server with the lowest current load or fastest response. This creates a structural weakness because it tends to repeatedly select the same subset of “fast” servers, which can eventually lead to load concentration and potential hotspots, especially under bursty or heterogeneous workloads. It lacks awareness of task importance and long-term fairness.

PBLB introduces service differentiation, ensuring that high-priority requests are handled quickly. While this improves QoS for critical tasks, it often causes load imbalance, since high-priority requests are directed to a limited number of preferred servers. Additionally, low-priority tasks may suffer from starvation or excessive delay, increasing the overall average response time.

The hybrid algorithm overcomes these limitations by combining the strengths of both approaches through a weighted or conditional decision mechanism. It integrates FRLB’s responsiveness by selecting servers with a low current response time, and prioritization by ensuring critical requests are served efficiently; this results in a multi-objective optimization strategy, where high-priority tasks are still handled quickly (PBLB advantage), load is redistributed more evenly across all servers (FRLB advantage), and server selection avoids both over-concentration and priority bias. Moreover, the hybrid method introduces a balancing factor (such as α) that dynamically controls the trade-off between speed and fairness. This prevents the system from being overly greedy (like FRLB) or overly biased (like PBLB), which leading to reduced queue rise, lower variance in server utilization, and improved global resource efficiency. As a result, the hybrid approach achieves a lower average response time than PBLB (due to better load spreading), better load distribution than FRLB (due to priority-aware decisions), and more stable and scalable performance under varying workloads.

The hybrid algorithm is better because it transforms load balancing from a single-objective, reactive process into a balanced, adaptive, multi-objective strategy, which is essential for modern distributed systems with heterogeneous workloads and QoS requirements.

Table 5 represents the average response time and server load of the 20 servers for the FRLB, PBLB, and hybrid algorithms, while Figure 6 and Figure 7 illustrate the results visually.

Table 5. Average response time and servers load for FRLB, PBLB, and hybrid algorithms.

	Average Response Time	Average Server Load
FRLB	5.770251044	25
PBLB	6.833652	25
Hybrid	3.846154	24.8

Figure 6. Average server load of FRLB, PBLB, and hybrid algorithms.

Figure 7. Average response time of FRLB, PBLB, and hybrid algorithms.

It is obvious that the hybrid protocol achieves better performance than FRLB and PBLB protocols as the average load and response time are less than the other two protocols.

The improved average response time achieved by the hybrid-ML algorithm compared to FRLB and PBLB can be justified by its integrated and predictive decision-making capability; FRLB selects servers purely based on instantaneous response time and PBLB prioritizes requests according to predefined or dynamically adjusted priorities. Both approaches rely mainly on current system states, making them reactive rather than proactive. The weighted combination of FRLB and PBLB balances the trade-off between speed and fairness, which reduces bottlenecks and improves resource utilization. As a result, tasks are distributed more efficiently across servers, leading to consistently lower waiting times and faster overall response.

While the hybrid FRLB–PBLB algorithm improves performance by combining speed and priority awareness, its limitations highlight the need for adaptive parameter tuning and predictive intelligence (ML integration) to make it fully applicable in real-world large-scale environments.

The effectiveness of the hybrid model strongly depends on the choice of the weighting parameter (α), which balances FRLB and PBLB decisions. A fixed α may not perform optimally under all traffic conditions, leading to suboptimal trade-offs between response time and load distribution. In its basic form, the hybrid algorithm is still largely reactive, relying on current system states (load, response time, and priority) rather than predicting future server conditions. This limits its ability to prevent upcoming congestion compared to fully intelligent or learning-based systems.

5. Conclusions

This paper presented a hybrid load-balancing algorithm that integrates the strengths of Fastest Response Load Balancing (FRLB) and Priority-Based Load Balancing (PBLB) to address the limitations of conventional approaches in dynamic and heterogeneous environments. The proposed method was designed to simultaneously minimize response time while maintaining balanced workload distribution across multiple servers. Unlike FRLB, which focuses primarily on immediate response time and may lead to load concentration, and PBLB, which emphasizes priority handling at the expense of fairness, the hybrid algorithm achieves a balanced trade-off between responsiveness and equitable resource utilization.

Simulation results conducted in MATLAB with 20 servers demonstrated that the hybrid approach consistently outperforms PBLB in terms of response time while maintaining a more uniform load distribution compared to FRLB. The integration mechanism, governed by a weighting factor, enables adaptive decision-making that accounts for both server conditions and task priorities. This leads to reduced congestion, improved system stability, and enhanced QoS, particularly under varying workload conditions.

Furthermore, the hybrid algorithm provides a flexible framework that can be extended to incorporate intelligent techniques such as machine learning for predictive decision-making. The results confirm that combining complementary strategies is more effective than relying on a single load-balancing policy, especially in modern distributed systems such as cloud computing and large-scale web services.

In conclusion, the proposed hybrid FRLB–PBLB algorithm offers a robust, scalable, and efficient solution for load balancing, achieving improved performance in both response time and load distribution. Future work will focus on integrating adaptive learning models and real-time optimization techniques to further enhance system performance under highly dynamic network conditions.