负载均衡--加权随机算法（Weight Random）

最新推荐文章于 2024-04-30 20:51:11 发布
最新推荐文章于 2024-04-30 20:51:11 发布
阅读量1.5k 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： java 算法 文章标签： 轮询调度 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chinawangfei/article/details/109646579
本文介绍了一种基于服务器配置和负载的加权随机调度算法。该算法通过为不同服务器分配权重来实现请求的智能分发，确保高配置服务器承担更多负载。通过Java实现，演示了如何根据权重动态选择服务器。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

加权随机法根据服务器的配置和系统的负载，分配不同的权重，按照权重随机请求后端服务器。

一、算法描述

假设有 N 台服务器 S = {S0, S1, S2, …, Sn}，权重为 W = {W0, W1, W2, …, Wn}，权重之和为 weightSum， 服务器列表为 serverList，算法可以描述为：
1、初始化 serverList，将 W0 个 S0 加入至serverList，将 W1 个 S1 加入至serverList，依据此规则，将所有的服务器加入至 serverList 中；
2、通过随机函数生成 0 到 weightSum 之间的任意整数，将该数字作为索引，从 serverList 中获取对应的服务器；

假定我们现在有如下四台服务器：

服务器地址权重
192.168.1.11
192.168.1.22
192.168.1.33
192.168.1.44

初始化服务列表后， serverList 如下：

服务器地址序号
192.168.1.11
192.168.1.22
192.168.1.23
192.168.1.34
192.168.1.35
192.168.1.36
192.168.1.47
192.168.1.48
192.168.1.49
192.168.1.410

首先，根据权重的不同，向 serverList 添加相应个数的服务器；然后，通过随机算法，随机获取访问的服务器。

二、java代码实现

package com.yidian.wemedia.civilization.schedulealgothrim;

import com.google.common.collect.SortedMultiset;
import com.google.common.collect.TreeMultiset;
import org.apache.commons.collections4.CollectionUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.TreeMap;

class Server implements Serializable {
    private static final long serialVersionUID = 7246747589293111189L;

    private String server;
    private Integer weight;
    private String description;

    public Server(String server, String description, Integer weight) {
        this.server = server;
        this.description = description;
        this.weight = weight;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }


    public String getServer() {
        return server;
    }

    public void setServer(String server) {
        this.server = server;
    }

    public Integer getWeight() {
        return weight;
    }

    public void setWeight(Integer weight) {
        this.weight = weight;
    }
}

class ServerManager {
    public static Map<String, Server> serverMap = new TreeMap<>();

    static {
        serverMap.put("192.168.1.1", new Server("192.168.1.1", "第1台server", 1));
        serverMap.put("192.168.1.2", new Server("192.168.1.2", "第2台server", 2));
        serverMap.put("192.168.1.3", new Server("192.168.1.3", "第3台server", 3));
        serverMap.put("192.168.1.4", new Server("192.168.1.4", "第4台server", 4));
        serverMap.put("192.168.1.5", new Server("192.168.1.5", "第4台server", 0));
    }
}

class RandomBalance {
    private static final Random RANDOM = new Random();
    private static ArrayList<String> middleServerList;
    private static Integer weightSum = 0;

    public static String getServer() {
        if (CollectionUtils.isEmpty(middleServerList)) {
            ArrayList<String> serverList = new ArrayList<>();
            Integer tempWeightSum = 0;

            Set<String> serverSet = ServerManager.serverMap.keySet();
            for (String server : serverSet) {
                Integer weight = ServerManager.serverMap.get(server).getWeight();
                tempWeightSum += weight;
                for (int i = 0; i < weight; i++) {
                    serverList.add(server);
                }
            }
            middleServerList = serverList;
            weightSum = tempWeightSum;
        }

        return middleServerList.get(RANDOM.nextInt(weightSum));
    }
}

public class WeightRandomScheduleTest {
    public static void main(String[] args) {
        SortedMultiset<String> serverSet = TreeMultiset.create();
        for (int i = 0; i < 100; i++) {
            String server = RandomBalance.getServer();
            Server curServer = ServerManager.serverMap.get(server);
            System.out.println(server + ", " + curServer.getDescription());
            serverSet.add(server, 1);
        }

        ServerManager.serverMap.forEach((key, value)->{
            System.out.println(key + ", count：" + serverSet.count(key));
        });
    }
}

运行结果如下所示：

192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.2, 第2台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.2, 第2台server
192.168.1.3, 第3台server
192.168.1.2, 第2台server
192.168.1.1, 第1台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.2, 第2台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.2, 第2台server
192.168.1.1, 第1台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.1, 第1台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.1, 第1台server
192.168.1.4, 第4台server
192.168.1.2, 第2台server
192.168.1.2, 第2台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.1, 第1台server
192.168.1.3, 第3台server
192.168.1.3, 第3台server
192.168.1.2, 第2台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.1, 第1台server
192.168.1.3, 第3台server
192.168.1.2, 第2台server
192.168.1.2, 第2台server
192.168.1.4, 第4台server
192.168.1.2, 第2台server
192.168.1.4, 第4台server
192.168.1.1, 第1台server
192.168.1.2, 第2台server
192.168.1.2, 第2台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.1, 第1台server
192.168.1.2, 第2台server
192.168.1.2, 第2台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.3, 第3台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.2, 第2台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.1, 第1台server
192.168.1.2, 第2台server
192.168.1.4, 第4台server
192.168.1.2, 第2台server
192.168.1.2, 第2台server
192.168.1.3, 第3台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.4, 第4台server
192.168.1.2, 第2台server
192.168.1.3, 第3台server
192.168.1.1, 第1台server
192.168.1.3, 第3台server
192.168.1.1, count：10
192.168.1.2, count：20
192.168.1.3, count：28
192.168.1.4, count：42
192.168.1.5, count：0

说明：
1、首先，使用 Random 对象随机生成 [0, weightSum) 的整数；然后，通过索引获取到服务器。weightSum其实就是serverList.size()。
2、在多线程的情况下，若线程A修改 ServerManager.serverMap 的值，则线程B无法即时拿到线程A修改后的值，可能会导致请求错误，需要调用方进行容错处理。
3、从宏观的角度看，访问量越大，负载越均衡。从微观的角度看，局部并不那么均衡。

负载均衡加权随机算法的实现（Java）
2301_79326588的博客
08-14 250
然后遍历服务器列表，累计每个服务器的权重，如果累计权重超过或等于randomWeight，则返回相应的服务器。负载均衡算法解决了这个问题，其中一种常见的算法是加权随机算法。负载均衡加权随机算法的基本原理是根据服务器的权重来决定请求被分发到哪台服务器上。在上述代码中，我们首先定义了一个LoadBalancer类作为负载均衡器，其中使用servers和weights两个列表来存储服务器实例和对应的权重。通过该算法，我们可以根据服务器的权重进行负载均衡，实现高效的请求分发和服务器负载均衡。
Java负载均衡实战：5种常见算法原理与代码实现
最新发布
AI开发架构师
06-05 653
在“双十一”这样的高并发场景中，单个服务器就像“一个人同时接100个外卖订单”，必然崩溃。负载均衡（Load Balancing）就像“外卖平台的订单调度系统”，把请求均匀分配给多台服务器，避免“忙的忙死，闲的闲死”。本文聚焦5种最常用的负载均衡算法，覆盖从基础轮询到高级一致性哈希的全场景，帮助你理解“为什么选这个算法”“怎么用Java实现”。本文先通过“奶茶店排队”故事引出负载均衡核心问题，再用“5个生活化案例”讲解算法原理，接着提供Java代码实现，最后结合Nginx、Redis等工具分析实战场景。
加权随机算法
qq_41800087的博客
12-07 1455
//待随机类 class Temp{ //名字 String name; //权重 double wight; public Temp(String name,double wight){ this.name=name; this.wight=wight; } public double get() { ...
负载均衡算法--加权随机法（Weight Random）
天将降大任于是人
05-16 8570
接上一篇博文：负载均衡算法–随机法（Random），文本讲解加权随机算法。 算法描述 假设有 N 台服务器 S = {S0, S1, S2, …, Sn}，默认权重为 W = {W0, W1, W2, …, Wn}，权重之和为 weightSum， 服务器列表为 serverList，算法可以描述为： 1、初始化 serverList，将 W0 个 S0 加入至serverList，将 W1 个 ...
负载均衡-加权随机算法
CJCC白朴的博客
06-01 1563
由于访问概率大致相同，所以如果部分服务器性能不一致的话，容易导致性能差的服务器压力过大，所以要根据服务器性能不一致的情况，给性能好的服务器多处理请求，给差的少分配请求（能者多劳）所以就需要在轮询算法的基础上给每台服务器设置权重，延伸为加权轮询算法
python 加权随机算法_python的random模块及加权随机算法的python实现
weixin_39637921的博客
12-03 377
random是用于生成随机数的，我们可以利用它随机生成数字或者选择字符串。random.seed(x)改变随机数生成器的种子seed。一般不必特别去设定seed，Python会自动选择seed。random.random() 用于生成一个随机浮点数n,0 <= n < 1random.uniform(a,b) 用于生成一个指定范围内的随机浮点数，生成的随机整数a<=n...
应用级算法系列（五）-负载均衡算法
dengwei_dw的专栏
04-30 1067
负载均衡，英文名称为Load Balance，其含义就是指将负载（工作任务）进行平衡、分摊到多个操作单元上进行运行，例如FTP服务器、Web服务器、企业核心应用服务器和其它主要任务服务器等，从而协同完成工作任务。既然涉及到多个机器，就涉及到任务如何分发，这就是负载均衡算法问题。
初探负载均衡算法【随机、轮询、加权随机、加权轮询、平滑加权轮询】
popofzk的博客
02-14 4018
简介 负载平衡（Load balancing）是一种在多个计算机（网络、CPU、磁盘）之间均匀分配资源，以提高资源利用的技术。使用负载均衡可以最大化服务吞吐量，可能最小化响应时间，同时由于使用负载均衡时，会使用多个服务器节点代单点服务，也提高了服务的可用性。 负载均衡的实现可以软件可以硬件，硬件如大名鼎鼎的 F5 负载均衡设备，软件如 NGINX 中的负载均衡实现，又如 Springcloud Ribbon 组件中的负载均衡实现。本文主要从软件层面来说明其实现算法。 负载均衡算法主要分为以下6大类： 随机
weight-random:CDC +线性搜索算法的加权随机
05-10
加权随机：从离散概率分布O（n）进行采样的算法 计算列表的离散累积密度函数（CDF）–或简单地说就是权重的累积和数组。 然后生成一个介于0和所有权重之和之间的随机数，进行线性搜索以在离散CDF数组中找到该随机数，并获取与该条目对应的值-这是加权随机数。 安装 npm install weight-random 用法 import { random } from 'weight-random' ; const prizes = [ { title : 'first prize' , weight : 0.6 } , { title : 'second prize' , weight : 0.2 } , { title : 'third prize' , weight : 0.15 } , { title : 'fourth prize' , weight : 0.01 }
python 加权随机算法_加权随机算法 - 飞儿飞的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_39670464的博客
12-03 201
加权随机算法一般应用在以下场景：有一个集合S，里面比如有A,B,C,D这四项。这时我们想随机从中抽取一项，但是抽取的概率不同，比如我们希望抽到A的概率是50%,抽到B和C的概率是20%,D的概率是10%。一般来说，我们可以给各项附一个权重，抽取的概率正比于这个权重。那么上述集合就成了：{A:5，B:2，C:2，D:1}方法一：扩展这个集合，使每一项出现的次数与其权重正相关。在上述例子这个集合扩展成...
负载均衡（加权随机法）
cpy1356140308的博客
05-31 225
总体而言，这段代码使用带有权重的随机数生成算法从给定的服务器列表中按照权重随机选择一个服务器，实现了加权负载均衡的功能。中，并根据权重的数量重复添加。例如，如果某服务器的权重为2，则将其添加两次到。，其中key为服务器的IP地址，value为服务器的权重。方法来模拟负载均衡过程。打印出随机选择的服务器IP地址。方法是主要的负载均衡方法。在该方法中，首先创建了一个。中随机选择一个位置，然后返回对应的服务器IP地址。中的key（即服务器的IP地址）添加到。在静态代码块中，定义了一个。来存储服务器的信息。
加权随机数
echo_hello_world的博客
05-16 945
数，可以根据各个元素的权重返回随机数 （加权随机数）    function(Array_A，n)    Array_A：是一个数组，表示各个元素出现的概率，        n：为需要返回的元素个数    如果n=1，则返回一个元素（Array_A中的key） ， n=2则返回两个元素（Array_A中的key）示例：function({20,50,30},1): 返回长度为1的数组，其中返回值为...
加权随机算法随笔
m0_49908016的博客
04-13 560
开发一个加权随机算法： 核心主要有两点，一个是概率补偿，一个是即时更新权重占比 public static <T> Set<T> weightRandomSelect(Map<T, Double> weightMap, int k) { double weightSum = 0; Set<T> result = new HashSet<>(); for (Map.Entry<T, Dou
加权随机抽样算法
热门推荐
Code_LT的博客
02-18 1万+
1. 基于均匀分布概率的算法   例如，3等奖抽中的概率是70%，2等奖是20%，1等奖是10%，这样，大部分人都只能中3等奖，小部分人是二等奖，而只有特别少的人才可能拿到一等奖。产生0-100之间的均匀分布的随机数，当随机数在0-70时，就获得3等奖，70-90是2等奖，90-100是一等奖。   另一个例子：按权重均一化后，编号3被抽中的概率要求是70%，5出现的概率为25%，0出现的...
负载均衡算法的数学原理
05-31
### 负载均衡算法背后的数学原理分析 负载均衡算法的核心在于通过合理的数学模型和统计方法，将请求均匀地分配到多个服务器上，从而最大化系统的吞吐量并最小化响应时间。以下是几种常见负载均衡算法的数学原理分析。 #### 1. 轮询算法 (Round Robin) 轮询算法是一种最简单的负载均衡策略，假设所有服务器的处理能力相同。它按照固定的顺序依次将请求分发给每个服务器。 从数学角度来看，轮询算法可以被看作一个等概率分布问题。如果系统中有 \( n \) 台服务器，则每台服务器接收到请求的概率为 \( \frac{1}{n} \)[^4]。然而，当请求服务间隔时间变化较大时，这种等概率分布可能导致实际负载不均衡。因此，轮询算法适合于服务器性能一致且请求到达较为均匀的场景。 #### 2. 加权轮询算法 (Weighted Round Robin) 加权轮询算法在轮询的基础上引入了权重的概念，用于反映不同服务器的处理能力差异。假设服务器 \( i \) 的权重为 \( w_i \)，则其接收到请求的概率可以表示为： \[ P(i) = \frac{w_i}{\sum_{j=1}^{n} w_j} \] 其中 \( n \) 是服务器总数[^3]。加权轮询算法通过调整权重参数，使得高性能服务器能够承担更多的请求，从而实现更优的负载均衡效果。 #### 3. 最小连接数算法 (Least Connections) 最小连接数算法根据当前服务器的连接数来决定请求的分配。假设服务器 \( i \) 当前的连接数为 \( c_i \)，则请求会被分配给连接数最少的服务器。 从数学角度看，该算法的目标是最小化整个系统的加权平均连接数： \[ \text{minimize } \sum_{i=1}^{n} c_i \] 此外，为了进一步优化性能，通常会结合权重参数 \( w_i \)，使得高权重服务器能够承载更多连接。此时，目标函数变为： \[ \text{minimize } \sum_{i=1}^{n} \frac{c_i}{w_i} \][^2] #### 4. 哈希一致性算法 (Consistent Hashing) 哈希一致性算法通过将请求映射到一个固定范围的虚拟节点上来实现负载均衡。假设请求的哈希值为 \( h(r) \)，并且系统中有 \( n \) 个服务器，则请求会被分配到距离 \( h(r) \) 最近的服务器上。 从数学角度看，一致性哈希算法的核心是环形空间上的模运算。具体而言，服务器 \( i \) 的位置可以通过以下公式计算： \[ p_i = h(s_i) \mod M \] 其中 \( s_i \) 是服务器 \( i \) 的标识符，\( M \) 是哈希空间的大小。通过这种方式，一致性哈希算法能够在服务器增减时保持大部分请求的分配不变，从而减少缓存失效带来的开销[^1]。 #### 5. 随机算法 (Random Algorithm) 随机算法通过生成随机数来决定请求的分配。假设服务器 \( i \) 的权重为 \( w_i \)，则其被选中的概率为： \[ P(i) = \frac{w_i}{\sum_{j=1}^{n} w_j} \] 与加权轮询类似，随机算法也支持权重调整，但其分配过程具有一定的随机性。这使得随机算法在某些情况下能够更好地应对突发流量[^4]。 --- ```python import random def weighted_random_selection(servers): total_weight = sum(server['weight'] for server in servers) rand = random.uniform(0, total_weight) cumulative_weight = 0 for server in servers: cumulative_weight += server['weight'] if cumulative_weight >= rand: return server['name'] ``` --- ### 总结 负载均衡算法的数学原理主要涉及概率分布、优化理论和哈希函数等领域。不同的算法适用于不同的应用场景，选择合适的算法需要综合考虑服务器性能、请求特征以及系统规模等因素。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值