java 负载均衡算法_超详细生产级负载均衡算法总结

最新推荐文章于 2023-05-20 23:42:00 发布
最新推荐文章于 2023-05-20 23:42:00 发布
阅读量153 收藏
点赞数
文章标签： java 负载均衡算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_31862047/article/details/114170469
版权

生产级负载均衡算法详解

负载均衡介绍

负载均衡，英文名称为Load Balance，指由多台服务器以对称的方式组成一个服务器集合，每台服务器都具有等价的地位，都可以单独对外提供服务而无须其他服务器的辅助。

通过某种负载分担技术，将外部发送来的请求均匀分配到对称结构中的某一台服务器上，而接收到请求的服务器独立地回应客户的请求。

负载均衡能够平均分配客户请求到服务器阵列，借此提供快速获取重要数据，解决大量并发访问服务问题，这种集群技术可以用最少的投资获得接近于大型主机的性能。

负载均衡方式

负载均衡分为软件负载均衡和硬件负载均衡

建议没有相关软件使用经验的朋友们不要太纠结他们的不同之处，可继续往下看I

软件负载均衡

常见的负载均衡软件有Nginx、LVS、HAProxy。

关于这几个软件的特点比较不是本文重点，本文就不多做阐述。

硬件负载均衡

常见的负载均衡硬件有Array、F5。

负载均衡算法

常见的负载均衡算法有：随机算法、加权轮询、一致性hash、最小活跃数算法。

千万别以为这几个算法看上去都特别简单，但其实真正在生产上用到时会远比你想的复杂

算法前提条件

定义一个服务器列表，每个负载均衡的算法会从中挑出一个服务器作为算法的结果。public class ServerIps {

private static final List LIST = Arrays.asList(

"192.168.0.1",

"192.168.0.2",

"192.168.0.3",

"192.168.0.4",

"192.168.0.5",

"192.168.0.6",

"192.168.0.7",

"192.168.0.8",

"192.168.0.9",

"192.168.0.10"

);

}

随机算法-RandomLoadBalance

先来个最简单的实现。public class Random {

public static String getServer() {

// 生成一个随机数作为list的下标值

java.util.Random random = new java.util.Random();

int randomPos = random.nextInt(ServerIps.LIST.size());

return ServerIps.LIST.get(randomPos);

}

public static void main(String[] args) {

// 连续调用10次

for (int i=0; i<10; i++) {

System.out.println(getServer());

}

}

}运行结果：

192.168.0.3

192.168.0.4

192.168.0.7

192.168.0.1

192.168.0.2

192.168.0.7

192.168.0.3

192.168.0.9

192.168.0.1

192.168.0.1

当调用次数比较少时，Random 产生的随机数可能会比较集中，此时多数请求会落到同一台服务器上，只有在经过多次请求后，才能使调用请求进行“均匀”分配。调用量少这一点并没有什么关系，负载均衡机制不正是为了应对请求量多的情况吗，所以随机算法也是用得比较多的一种算法。但是，上面的随机算法适用于每天机器的性能差不多的时候，实际上，生产中可能某些机器的性能更高一点，它可以处理更多的请求，所以，我们可以对每台服务器设置一个权重。

在ServerIps类中增加服务器权重对应关系MAP，权重之和为50：public static final Map WEIGHT_LIST = new HashMap();

static {

// 权重之和为50

WEIGHT_LIST.put("192.168.0.1", 1);

WEIGHT_LIST.put("192.168.0.2", 8);

WEIGHT_LIST.put("192.168.0.3", 3);

WEIGHT_LIST.put("192.168.0.4", 6);

WEIGHT_LIST.put("192.168.0.5", 5);

WEIGHT_LIST.put("192.168.0.6", 5);

WEIGHT_LIST.put("192.168.0.7", 4);

WEIGHT_LIST.put("192.168.0.8", 7);

WEIGHT_LIST.put("192.168.0.9", 2);

WEIGHT_LIST.put("192.168.0.10", 9);

}

那么现在的随机算法应该要改成权重随机算法，当调用量比较多的时候，服务器使用的分布应该近似对应权重的分布。

权重随机算法

简单的实现思路是，把每个服务器按它所对应的服务器进行复制，具体看代码更加容易理解public class WeightRandom {

public static String getServer() {

// 生成一个随机数作为list的下标值

List ips = new ArrayList();

for (String ip : ServerIps.WEIGHT_LIST.keySet()) {

Integer weight = ServerIps.WEIGHT_LIST.get(ip);

// 按权重进行复制

for (int i=0; i

ips.add(ip);

}

}

java.util.Random random = new java.util.Random();

int randomPos = random.nextInt(ips.size());

return ips.get(randomPos);

}

public static void main(String[] args) {

// 连续调用10次

for (int i=0; i<10; i++) {

System.out.println(getServer());

}

}

}运行结果：

192.168.0.8

192.168.0.2

192.168.0.7

192.168.0.10

192.168.0.8

192.168.0.8

192.168.0.4

192.168.0.7

192.168.0.6

192.168.0.8

这种实现方法在遇到权重之和特别大的时候就会比较消耗内存，因为需要对ip地址进行复制，权重之和越大那么上文中的ips就需要越多的内存，下面介绍另外一种实现思路。

假设我们有一组服务器 servers = [A, B, C]，他们对应的权重为 weights = [5, 3, 2]，权重总和为10。现在把这些权重值平铺在一维坐标值上，[0, 5) 区间属于服务器 A，[5, 8) 区间属于服务器 B，[8, 10) 区间属于服务器 C。接下来通过随机数生成器生成一个范围在 [0, 10) 之间的随机数，然后计算这个随机数会落到哪个区间上。比如数字3会落到服务器 A 对应的区间上，此时返回服务器 A 即可。权重越大的机器，在坐标轴上对应的区间范围就越大，因此随机数生成器生成的数字就会有更大的概率落到此区间内。只要随机数生成器产生的随机数分布性很好，在经过多次选择后，每个服务器被选中的次数比例接近其权重比例。比如，经过一万次选择后，服务器 A 被选中的次数大约为5000次，服务器 B 被选中的次数约为3000次，服务器 C 被选中的次数约为2000次。

假设现在随机数offset=7：offset<5 is false，所以不在[0, 5)区间，将offset = offset - 5(offset=2)

offset<3 is true，所以处于[5, 8)区间，所以应该选用B服务器

实现如下public class WeightRandomV2 {

public static String getServer() {

int totalWeight = 0;

boolean sameWeight = true; // 如果所有权重都相等，那么随机一个ip就好了

Object[] weights = ServerIps.WEIGHT_LIST.values().toArray();

for (int i = 0; i 

Integer weight = (Integer) weights[i];

totalWeight += weight;

if (sameWeight && i > 0 && !weight.equals(weights[i - 1])) {

sameWeight = false;

}

}

java.util.Random random = new java.util.Random();

int randomPos = random.nextInt(totalWeight);

if (!sameWeight) {

for (String ip : ServerIps.WEIGHT_LIST.keySet()) {

Integer value = ServerIps.WEIGHT_LIST.get(ip);

if (randomPos 

return ip;

}

randomPos = randomPos - value;

}

}

return (String) ServerIps.WEIGHT_LIST.keySet().toArray()[new java.util.Random().nextInt(ServerIps.WEIGHT_LIST.size())];

}

public static void main(String[] args) {

// 连续调用10次

for (int i = 0; i 

System.out.println(getServer());

}

}

}

这就是另外一种权重随机算法。

轮询算法-RoundRobinLoadBalance

简单的轮询算法很简单public class RoundRobin {

// 当前循环的位置

private static Integer pos = 0;

public static String getServer() {

String ip = null;

// pos同步

synchronized (pos) {

if (pos >= ServerIps.LIST.size()) {

pos = 0;

}

ip = ServerIps.LIST.get(pos);

pos++;

}

return ip;

}

public static void main(String[] args) {

// 连续调用10次

for (int i = 0; i 

System.out.println(getServer());

}

}

}运行结果：

192.168.0.1

192.168.0.2

192.168.0.3

192.168.0.4

192.168.0.5

192.168.0.6

192.168.0.7

192.168.0.8

192.168.0.9

192.168.0.10

192.168.0.1

这种算法很简单，也很公平，每台服务轮流来进行服务，但是有的机器性能好，所以能者多劳，和随机算法一下，加上权重这个维度之后，其中一种实现方法就是复制法，这里就不演示了，这种复制算法的缺点和随机算法的是一样的，比较消耗内存，那么自然就有其他实现方法。我下面来介绍一种算法：

这种算法需要加入一个概念：调用编号，比如第1次调用为1， 第2次调用为2， 第100次调用为100，调用编号是递增的，所以我们可以根据这个调用编号推算出服务器。

假设我们有三台服务器 servers = [A, B, C]，对应的权重为 weights = [ 2, 5, 1], 总权重为8，我们可以理解为有8台“服务器”，这是8台“不具有并发功能”，其中有2台为A，5台为B，1台为C，一次调用过来的时候，需要按顺序访问，比如有10次调用，那么服务器调用顺序为AABBBBBCAA，调用编号会越来越大，而服务器是固定的，所以需要把调用编号“缩小”，这里对调用编号进行取余，除数为总权重和，比如：1号调用，1%8=1；

2号调用，2%8=2；

3号调用，3%8=3；

8号调用，8%8=0；

9号调用，9%8=1；

100号调用，100%8=4；

我们发现调用编号可以被缩小为0-7之间的8个数字，问题是怎么根据这个8个数字找到对应的服务器呢？和我们随机算法类似，这里也可以把权重想象为一个坐标轴“0-----2-----7-----8”

1号调用，1%8=1，offset = 1, offset <= 2 is true，取A；

2号调用，2%8=2；offset = 2，offset <= 2 is true, 取A;

3号调用，3%8=3；offset = 3, offset <= 2 is false, offset = offset - 2, offset = 1, offset <= 5，取B

8号调用，8%8=0；offset = 0, 特殊情况，offset = 8，offset <= 2 is false, offset = offset - 2, offset = 6, offset <= 5 is false, offset = offset - 5, offset = 1, offset <= 1 is true, 取C;

9号调用，9%8=1；// …

100号调用，100%8=4； //…

实现：

模拟调用编号获取工具：public class Sequence {

public static Integer num = 0;

public static Integer getAndIncrement() {

return ++num;

}

}public class WeightRoundRobin {

private static Integer pos = 0;

public static String getServer() {

int totalWeight = 0;

boolean sameWeight = true; // 如果所有权重都相等，那么随机一个ip就好了

Object[] weights = ServerIps.WEIGHT_LIST.values().toArray();

for (int i = 0; i 

Integer weight = (Integer) weights[i];

totalWeight += weight;

if (sameWeight && i > 0 && !weight.equals(weights[i - 1])) {

sameWeight = false;

}

}

Integer sequenceNum = Sequence.getAndIncrement();

Integer offset = sequenceNum % totalWeight;

offset = offset == 0 ?  totalWeight : offset;

if (!sameWeight) {

for (String ip : ServerIps.WEIGHT_LIST.keySet()) {

Integer weight = ServerIps.WEIGHT_LIST.get(ip);

if (offset <= weight) {

return ip;

}

offset = offset - weight;

}

}

String ip = null;

synchronized (pos) {

if (pos >= ServerIps.LIST.size()) {

pos = 0;

}

ip = ServerIps.LIST.get(pos);

pos++;

}

return ip;

}

public static void main(String[] args) {

// 连续调用11次

for (int i = 0; i 

System.out.println(getServer());

}

}

}运行结果：

192.168.0.1

192.168.0.2

192.168.0.2

192.168.0.2

192.168.0.2

192.168.0.2

192.168.0.2

192.168.0.2

192.168.0.2

192.168.0.3

192.168.0.3

但是这种算法有一个缺点：一台服务器的权重特别大的时候，他需要连续的的处理请求，但是实际上我们想达到的效果是，对于100次请求，只要有100*8/50=16次就够了，这16次不一定要连续的访问，比如假设我们有三台服务器 servers = [A, B, C]，对应的权重为 weights = [5, 1, 1] , 总权重为7，那么上述这个算法的结果是：AAAAABC，那么如果能够是这么一个结果呢：AABACAA，把B和C平均插入到5个A中间，这样是比较均衡的了。

我们这里可以改成平滑加权轮询。

平滑加权轮询

思路：每个服务器对应两个权重，分别为 weight 和 currentWeight。其中 weight 是固定的，currentWeight 会动态调整，初始值为0。当有新的请求进来时，遍历服务器列表，让它的 currentWeight 加上自身权重。遍历完成后，找到最大的 currentWeight，并将其减去权重总和，然后返回相应的服务器即可。

a28053cb4d410f565293b454ad9fb855.png

如上，经过平滑性处理后，得到的服务器序列为 [A, A, B, A, C, A, A]，相比之前的序列 [A, A, A, A, A, B, C]，分布性要好一些。初始情况下 currentWeight = [0, 0, 0]，第7个请求处理完后，currentWeight 再次变为 [0, 0, 0]。

实现：// 增加一个Weight类，用来保存ip, weight(固定不变的原始权重), currentweight(当前会变化的权重)

public class Weight {

private String ip;

private Integer weight;

private Integer currentWeight;

public Weight(String ip, Integer weight, Integer currentWeight) {

this.ip = ip;

this.weight = weight;

this.currentWeight = currentWeight;

}

public String getIp() {

return ip;

}

public void setIp(String ip) {

this.ip = ip;

}

public Integer getWeight() {

return weight;

}

public void setWeight(Integer weight) {

this.weight = weight;

}

public Integer getCurrentWeight() {

return currentWeight;

}

public void setCurrentWeight(Integer currentWeight) {

this.currentWeight = currentWeight;

}

}public class WeightRoundRobinV2 {

private static Map weightMap = new HashMap();

public static String getServer() {

// java8

int totalWeight = ServerIps.WEIGHT_LIST.values().stream().reduce(0, (w1, w2) -> w1+w2);

// 初始化weightMap，初始时将currentWeight赋值为weight

if (weightMap.isEmpty()) {

ServerIps.WEIGHT_LIST.forEach((key, value) -> {

weightMap.put(key, new Weight(key, value, value));

});

}

// 找出currentWeight最大值

Weight maxCurrentWeight = null;

for (Weight weight : weightMap.values()) {

if (maxCurrentWeight == null || weight.getCurrentWeight() > maxCurrentWeight.getCurrentWeight()) {

maxCurrentWeight = weight;

}

}

// 将maxCurrentWeight减去总权重和

maxCurrentWeight.setCurrentWeight(maxCurrentWeight.getCurrentWeight() - totalWeight);

// 所有的ip的currentWeight统一加上原始权重

for (Weight weight : weightMap.values()) {

weight.setCurrentWeight(weight.getCurrentWeight() + weight.getWeight());

}

// 返回maxCurrentWeight所对应的ip

return maxCurrentWeight.getIp();

}

public static void main(String[] args) {

// 连续调用10次

for (int i = 0; i 

System.out.println(getServer());

}

}

}

讲ServerIps里的数据简化为：WEIGHT_LIST.put("A", 5);

WEIGHT_LIST.put("B", 1);

WEIGHT_LIST.put("C", 1);

```运行结果：

A

A

B

A

C

A

A

A

A

B

这就是轮询算法，一个循环很简单，但是真正在实际运用的过程中需要思考更多。

一致性哈希算法-ConsistentHashLoadBalance

服务器集群接收到一次请求调用时，可以根据根据请求的信息，比如客户端的ip地址，或请求路径与请求参数等信息进行哈希，可以得出一个哈希值，特点是对于相同的ip地址，或请求路径和请求参数哈希出来的值是一样的，只要能再增加一个算法，能够把这个哈希值映射成一个服务端ip地址，就可以使相同的请求(相同的ip地址，或请求路径和请求参数)落到同一服务器上。

因为客户端发起的请求情况是无穷无尽的(客户端地址不同，请求参数不同等等)，所以对于的哈希值也是无穷大的，所以我们不可能把所有的哈希值都进行映射到服务端ip上，所以这里需要用到哈希环。如下图：

6653e065bf6d2daa30d8c7a5826942e0.png

• 哈希值如果需要ip1和ip2之间的，则应该选择ip2作为结果；

• 哈希值如果需要ip2和ip3之间的，则应该选择ip3作为结果；

• 哈希值如果需要ip3和ip4之间的，则应该选择ip4作为结果；

• 哈希值如果需要ip4和ip1之间的，则应该选择ip1作为结果；

上面这情况是比较均匀情况，如果出现ip4服务器不存在，那就是这样了：

8b386bf49ff542a3f6dab5a13090d6ff.png

会发现，ip3和ip1直接的范围是比较大的，会有更多的请求落在ip1上，这是不“公平的”，解决这个问题需要加入虚拟节点，比如：

dc929bf2678a34b78d5c5b785b6ee7c4.png

其中ip2-1, ip3-1就是虚拟结点，并不能处理节点，而是等同于对应的ip2和ip3服务器。

实际上，这只是处理这种不均衡性的一种思路，实际上就算哈希环本身是均衡的，你也可以增加更多的虚拟节点来使这个环更加平滑，比如：

c5d28a9e99975ad7f4196a03e8dd85e9.png

这个彩环也是“公平的”，并且只有ip1,2,3,4是实际的服务器ip，其他的都是虚拟ip。

那么我们怎么来实现呢？

对于我们的服务端ip地址，我们肯定知道总共有多少个，需要多少个虚拟节点也有我们自己控制，虚拟节点越多则流量越均衡，另外哈希算法也是很关键的，哈希算法越散列流量也将越均衡。

实现：public class ConsistentHash {

private static SortedMap virtualNodes = new TreeMap<>();

private static final int VIRTUAL_NODES = 160;

static {

// 对每个真实节点添加虚拟节点，虚拟节点会根据哈希算法进行散列

for (String ip : ServerIps.LIST) {

for (int i = 0; i 

int hash = getHash(ip+"VN"+i);

virtualNodes.put(hash, ip);

}

}

}

private static String getServer(String client) {

int hash = getHash(client);

// 得到大于该Hash值的排好序的Map

SortedMap subMap = virtualNodes.tailMap(hash);

// 大于该hash值的第一个元素的位置

Integer nodeIndex = subMap.firstKey();

// 如果不存在大于该hash值的元素，则返回根节点

if (nodeIndex == null) {

nodeIndex = virtualNodes.firstKey();

}

// 返回对应的虚拟节点名称

return subMap.get(nodeIndex);

}

private static int getHash(String str) {

final int p = 16777619;

int hash = (int) 2166136261L;

for (int i = 0; i 

hash = (hash ^ str.charAt(i)) * p;

hash += hash <

hash ^= hash >> 7;

hash += hash <

hash ^= hash >> 17;

hash += hash <

// 如果算出来的值为负数则取其绝对值

if (hash 

hash = Math.abs(hash);

return hash;

}

public static void main(String[] args) {

// 连续调用10次,随机10个client

for (int i = 0; i 

System.out.println(getServer("client" + i));

}

}

}

最小活跃数算法-LeastActiveLoadBalance

前面几种方法主要目标是使服务端分配到的调用次数尽量均衡，但是实际情况是这样吗？调用次数相同，服务器的负载就均衡吗？当然不是，这里还要考虑每次调用的时间，而最小活跃数算法则是解决这种问题的。

活跃调用数越小，表明该服务提供者效率越高，单位时间内可处理更多的请求。此时应优先将请求分配给该服务提供者。在具体实现中，每个服务提供者对应一个活跃数。初始情况下，所有服务提供者活跃数均为0。每收到一个请求，活跃数加1，完成请求后则将活跃数减1。在服务运行一段时间后，性能好的服务提供者处理请求的速度更快，因此活跃数下降的也越快，此时这样的服务提供者能够优先获取到新的服务请求、这就是最小活跃数负载均衡算法的基本思想。除了最小活跃数，最小活跃数算法在实现上还引入了权重值。所以准确的来说，最小活跃数算法是基于加权最小活跃数算法实现的。举个例子说明一下，在一个服务提供者集群中，有两个性能优异的服务提供者。某一时刻它们的活跃数相同，则会根据它们的权重去分配请求，权重越大，获取到新请求的概率就越大。如果两个服务提供者权重相同，此时随机选择一个即可。

实现：

因为活跃数是需要服务器请求处理相关逻辑配合的，一次调用开始时活跃数+1，结束是活跃数-1，所以这里就不对这部分逻辑进行模拟了，直接使用一个map来进行模拟。// 服务器当前的活跃数

public static final Map ACTIVITY_LIST = new LinkedHashMap();

static {

ACTIVITY_LIST.put("192.168.0.1", 2);

ACTIVITY_LIST.put("192.168.0.2", 0);

ACTIVITY_LIST.put("192.168.0.3", 1);

ACTIVITY_LIST.put("192.168.0.4", 3);

ACTIVITY_LIST.put("192.168.0.5", 0);

ACTIVITY_LIST.put("192.168.0.6", 1);

ACTIVITY_LIST.put("192.168.0.7", 4);

ACTIVITY_LIST.put("192.168.0.8", 2);

ACTIVITY_LIST.put("192.168.0.9", 7);

ACTIVITY_LIST.put("192.168.0.10", 3);

}public class LeastActive {

private static String getServer() {

// 找出当前活跃数最小的服务器

Optional minValue = ServerIps.ACTIVITY_LIST.values().stream().min(Comparator.naturalOrder());

if (minValue.isPresent()) {

List minActivityIps = new ArrayList<>();

ServerIps.ACTIVITY_LIST.forEach((ip, activity) -> {

if (activity.equals(minValue.get())) {

minActivityIps.add(ip);

}

});

// 最小活跃数的ip有多个，则根据权重来选，权重大的优先

if (minActivityIps.size() > 1) {

// 过滤出对应的ip和权重

Map weightList = new LinkedHashMap();

ServerIps.WEIGHT_LIST.forEach((ip, weight) -> {

if (minActivityIps.contains(ip)) {

weightList.put(ip, ServerIps.WEIGHT_LIST.get(ip));

}

});

int totalWeight = 0;

boolean sameWeight = true; // 如果所有权重都相等，那么随机一个ip就好了

Object[] weights = weightList.values().toArray();

for (int i = 0; i 

Integer weight = (Integer) weights[i];

totalWeight += weight;

if (sameWeight && i > 0 && !weight.equals(weights[i - 1])) {

sameWeight = false;

}

}

java.util.Random random = new java.util.Random();

int randomPos = random.nextInt(totalWeight);

if (!sameWeight) {

for (String ip : weightList.keySet()) {

Integer value = weightList.get(ip);

if (randomPos 

return ip;

}

randomPos = randomPos - value;

}

}

return (String) weightList.keySet().toArray()[new java.util.Random().nextInt(weightList.size())];

} else {

return minActivityIps.get(0);

}

} else {

return (String) ServerIps.WEIGHT_LIST.keySet().toArray()[new java.util.Random().nextInt(ServerIps.WEIGHT_LIST.size())];

}

}

public static void main(String[] args) {

// 连续调用10次,随机10个client

for (int i = 0; i 

System.out.println(getServer());

}

}

}

这里因为不会对活跃数进行操作，所以结果是固定的(担任在随机权重的时候会随机，具体看源码实现，以及运行结果即可理解)。

如果有疑问欢迎在评论区留言， 一起学习交流

人家卖汽车的啦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA常用负载均衡算法实现
农村外出务工男的博客
01-31 787
一、负载均衡的概念       在大型的分布式架构中,对于负载较高的服务来说,往往对应着多台机器组成的集群,当请求到来的时候,为了将请求均衡的分配给后端服务器需要有相应的负载均衡算法来支持,通过相应的负载均衡算法选取一台机器来处理客户端请求,这个过程称为服务的负载均衡。 二、常用负载均衡算法实现        常用的负载均衡算法主要有随机法,轮询法,加权随
java 负载均衡 算法_几种简单的负载均衡算法及其Java代码实现
weixin_32865081的博客
02-16 128
什么是负载均衡负载均衡，英文名称为Load Balance，指由多台服务器以对称的方式组成一个服务器集合，每台服务器都具有等价的地位，都可以单独对外提供服务而无须其他服务器的辅助。通过某种负载分担技术，将外部发送来的请求均匀分配到对称结构中的某一台服务器上，而接收到请求的服务器独立地回应客户的请求。负载均衡能够平均分配客户请求到服务器阵列，借此提供快速获取重要数据，解决大量并发访问服务问题，这种集...
java 负载均衡 算法_详解Java实现负载均衡的几种算法代码
weixin_39736150的博客
02-12 112
本篇文章主要介绍Java实现负载均衡的几种算法，具体如下：轮询:package class2.zookeeper.loadbalance;import java.util.ArrayList;import java.util.HashMap;import java.util.Map;import java.util.Set;/*** 負載均衡算法，輪詢法* @author guoy**/publi...
java里的负载均衡,Java实现负载均衡算法
weixin_39711914的博客
03-13 72
package com.hengyu.ticket.test;import java.math.BigInteger;import java.util.*;/*** Created by lgf on 2016/4/3.* java 实现负载均衡算法*/public class LoadBalancing {private final static String SERVER_MASTER = "...
详解Java实现负载均衡的几种算法代码
08-31
本篇文章主要介绍了详解Java实现负载均衡的几种算法代码 ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
几种简单的负载均衡算法及其Java代码实现
12-22
什么是负载均衡 　负载均衡，英文名称为Load Balance，指由多台服务器以对称的方式组成一个服务器集合，每台服务器都具有等价的地位，都可以单独对外提供服务而无须其他服务器的辅助。通过某种负载分担技术，将外部...
几种简单的负载均衡算法及java实现1
08-08
负载均衡算法及Java实现 负载均衡是指通过某种负载分担技术，将外部发送来的请求均匀分配到对称结构中的某一台服务器上，以解决大量并发访问服务问题。负载均衡能够平均分配客户请求到服务器阵列，借此提供快速获取...
algorithm蚂蚁群算法平均Java负载率实现_java
06-05
algorithm蚂蚁群算法平均Java负载率实现_java
Java使用Gateway自定义负载均衡过滤器
08-18
主要介绍了Java使用Gateway自定义负载均衡过滤器，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java 实现5种负载均衡算法
m0_69424697的博客
05-30 520
概念 负载均衡是将客户端请求访问，通过提前约定好的规则转发给各个server。其中有好几个种经典的算法，下面我们用Java实现这几种算法。 小伙伴们有兴趣想了解内容和更多相关学习资料的请点赞收藏+评论转发+关注我，后面会有很多干货。我有一些面试题、架构、设计类资料可以说是程序员面试必备！ 所有资料都整理到网盘了，需要的话欢迎下载！私信我回复【111】即可免费获取 轮询算法 轮询算法按顺序把每个新的连接请求分配给下一个服务器，最终把所有请求平分给所有的服务器。 优点：绝对公平 缺点：无.
Java实现5种负载均衡算法
xu990128638的专栏
11-16 2689
【代码】Java实现5种负载均衡算法。
详解常见负载均衡算法在Java中的实现
shadow_zed的博客
07-16 2016
一致性哈希算法中，就利用哈希环结构+哈希取模判断每个请求该落入的服务器，由于服务器IP、客户端IP或缓存的Key都是相同的，所以在服务器数量不变的情况，相同的哈希条件进行哈希取模，最终计算出来的值永远都是相同的。与前面分析的最小活跃数算法一样，最优响应算法也是一种动态算法，但它比最小活跃数算法更加智能，因为最小活跃数算法中，如果一台节点存在故障，导致它自身处理的请求数比较少，那么它会遭受最大的访问压力，这显然是并不合理的。遍历之前配置的服务器列表，用随机索引与每个节点的权重值进行判断。...........
【Java高级】常用的负载均衡算法
jayxiaoxionger的博客
05-20 1189
常用的负载均衡算法
算法高级（13）-常见负载均衡算法Java代码实现
十步杀一人-千里不留行
09-07 1699
我们在分布式系统常见负载均衡算法中对负载均衡及负载均衡算法进行了介绍，接下来我们用代码对常见的几种算法进行实现。 本文讲述的是”将外部发送来的请求均匀分配到对称结构中的某一台服务器上”的各种算法，并以Java代码演示每种算法的具体实现，OK，下面进入正题，在进入正题前，先写一个类来模拟Ip列表： import java.util.HashMap; /** * @author ashan...
负载均衡的几种算法Java实现代码
03-07 542
http://www.cnblogs.com/wxd0108/p/5465938.html 轮询 package class2.zookeeper.loadbalance; import java.util.ArrayList; import java.util.HashMap; import java.util.Map; import java.util.Set; /**
面试官：负载均衡的算法你了解不？
lixiaoxiong的专栏
01-01 828
本文转自：Java极客技术 上一篇文章我讲了关于负载均衡的三种算法，轮询法，随机法，最小连接法，这三种负载均衡的算法，但是关于负载均衡还有其他的算法，我们也需要你去看，而且在面试的过程中，很有可能是会问到的呦。 对于要实现高性能集群，选择好负载均衡器很重要，同时针对不同的业务场景选择合适的负载均衡算法也是非常重要的。之前已经罗列出几个了，接下来在说剩下的几个算法， 1. 源地址哈希算法 ...
Java基础知识总结：常见的负载均衡算法
旧时光 | YoungChen's 博客
01-23 1020
单机压力过大促使架构向集群模式转变，那么对于请求必定需要一个分发器进行任务分配和流量权衡，业界一般习惯于叫“负载均衡器”，但其实它的作用不仅仅在于平衡机器间的压力，还在于如何更智能的选择任务分发策略，并在一定时候提供降级等保护措施，总之对负载均衡器的理解不能局限在表面意思上。 本文谈谈常见的负载均衡算法，也是初级程序员面试中大概率出现的问题。 轮询 意思很简单，对台机器组成的集群，前置的负载均衡器...
java动态负载均衡算法
最新发布
06-02
Java动态负载均衡算法可以分为两种类型：基于客户端的负载均衡算法和基于服务端的负载均衡算法。 基于客户端的负载均衡算法是指客户端进行负载均衡，客户端通过一定的算法选择一个服务提供者进行调用。常见的基于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值