内容简介:记得,我刚工作的时候,同事说了一个故事:在他刚工作的时候,他同事有一天兴冲冲的跑到公司说,你们知道吗,公司请了个大牛。大牛?对,那人会写AJAX!哇,真是大牛啊,跟着他,可以学不少东西啊。我听了笑了,但有点难以理解,因为现在几乎只要是一个开发,都会写AJAX,怎么写个AJAX就算大牛呢?后来我明白了,三年前高深莫测的技术到现在变得普普通通,不足为奇,就像我们今天要讲的负载均衡,在几何时,负载均衡只有大牛才能玩转起来,但是到今天,一个小开发都可以聊上几句。现在,就让我们简单的看看负载均衡把。从负载均衡设备的角
记得,我刚工作的时候,同事说了一个故事:在他刚工作的时候,他同事有一天兴冲冲的跑到公司说,你们知道吗,公司请了个大牛。大牛?对,那人会写AJAX!哇,真是大牛啊,跟着他,可以学不少东西啊。我听了笑了,但有点难以理解,因为现在几乎只要是一个开发,都会写AJAX,怎么写个AJAX就算大牛呢?后来我明白了,三年前高深莫测的技术到现在变得普普通通,不足为奇,就像我们今天要讲的负载均衡,在几何时,负载均衡只有大牛才能玩转起来,但是到今天,一个小开发都可以聊上几句。现在,就让我们简单的看看负载均衡把。
从负载均衡设备的角度来看,分为硬件负载均衡和软件负载均衡:
- 硬件负载均衡:比如最常见的F5,还有Array等,这些负载均衡是商业的负载均衡器,性能比较好,毕竟他们的就是为了负载均衡而生的,背后也有非常成熟的团队,可以提供各种解决方案,但是价格比较昂贵,所以没有充足的理由,充足的软妹币是不会考虑的。
- 软件负载均衡:包括我们耳熟能详的Nginx,LVS,Tengine(阿里对Nginx进行的改造)等。优点就是成本比较低,但是也需要有比较专业的团队去维护,要自己去踩坑,去DIY。
从负载均衡的技术来看,分为服务端负载均衡和客户端负载均衡:
- 服务端负载均衡:当我们访问一个服务,请求会先到另外一台服务器,然后这台服务器会把请求分发到提供这个服务的服务器,当然如果只有一台服务器,那好说,直接把请求给那一台服务器就可以了,但是如果有多台服务器呢?这时候,就会根据一定的算法选择一台服务器。
- 客户端负载均衡:客户端服务均衡的概念貌似是有了服务治理才产生的,简单的来说,就是在一台服务器上维护着所有服务的ip,名称等信息,当我们在代码中访问一个服务,是通过一个组件访问的,这个组件会从那台服务器上取到所有提供这个服务的服务器的信息,然后通过一定的算法,选择一台服务器进行请求。
从负载均衡的算法来看,又分为 随机,轮询,哈希,最小压力,当然可能还会加上权重的概念,负载均衡的算法就是本文的重点了。
随机
随机就是没有规律的,随便从负载中获得一台,又分为完全随机和加权随机:
完全随机
public class Servers { public List<String> list = new ArrayList<>() { { add("192.168.1.1"); add("192.168.1.2"); add("192.168.1.3"); } }; } 复制代码
public class FullRandom { static Servers servers = new Servers(); static Random random = new Random(); public static String go() { var number = random.nextInt(servers.list.size()); return servers.list.get(number); } public static void main(String[] args) { for (var i = 0; i < 15; i++) { System.out.println(go()); } } } 复制代码
运行结果:
虽说现在感觉并不是那么随机,有的服务器经常被获得到,有的服务器获得的次数比较少,但是当有充足的请求次数,就会越来越平均,这正是随机数的一个特性。
完全随机是最简单的负载均衡算法了,缺点比较明显,因为服务器有好有坏,处理能力是不同的,我们希望性能好的服务器多处理些请求,性能差的服务器少处理一些请求,所以就有了加权随机。
加权随机
加权随机,虽然还是采用的随机算法,但是为每台服务器设置了权重,权重大的服务器获得的概率大一些,权重小的服务器获得的概率小一些。
关于加权随机的算法,有两种实现方式:
一种是网上流传的,代码比较简单:构建一个服务器的List,如果A服务器的权重是2,那么往List里面Add两次A服务器,如果B服务器的权重是7,那么我往List里面Add7次B服务器,以此类推,然后我再生成一个随机数,随机数的上限就是权重的总和,也就是List的Size。这样权重越大的,被选中的概率当然越高,代码如下:
public class Servers { public HashMap<String, Integer> map = new HashMap<>() { { put("192.168.1.1", 2); put("192.168.1.2", 7); put("192.168.1.3", 1); } }; } 复制代码
public class WeightRandom { static Servers servers = new Servers(); static Random random = new Random(); public static String go() { var ipList = new ArrayList<String>(); for (var item : servers.map.entrySet()) { for (var i = 0; i < item.getValue(); i++) { ipList.add(item.getKey()); } } int allWeight = servers.map.values().stream().mapToInt(a -> a).sum(); var number = random.nextInt(allWeight); return ipList.get(number); } public static void main(String[] args) { for (var i = 0; i < 15; i++) { System.out.println(go()); } } } 复制代码
运行结果:
可以很清楚的看到,权重小的服务器被选中的概率相对是比较低的。
当然我在这里仅仅是为了演示,一般来说,可以把构建服务器List的代码移动到静态代码块中,不用每次都构建。
这种实现方式相对比较简单,很容易就能想到,但是也有缺点,如果我几台服务器权重设置的都很大,比如上千,上万,那么服务器List也有上万条数据,这不是白白占用内存吗?
所以聪明的 程序员 想到了第二种方式:
为了方便解释,还是就拿上面的例子来说吧:
如果A服务器的权重是2,B服务器的权重是7,C服务器的权重是1:
- 如果我生成的随机数是1,那么落到A服务器,因为1<=2(A服务器的权重)
- 如果我生成的随机数是5,那么落到B服务器,因为5>2(A服务器的权重),5-2(A服务器的权重)=3,3<7(B服务器的权重)
- 如果我生成的随机数是10,那么落到C服务器,因为10>2(A服务器的权重),10-2(A服务器的权重)=8,8>7(B服务器的权重),8-7(B服务器的权重)=1, 1<=1(C服务器的权重)
不知道博客对于大于小于符号,会不会有特殊处理,所以我再截个图:
也许,光看文字描述还是不够清楚,可以结合下面丑到爆炸的图片来理解下:
- 如果生成的随机数是5,那么落到第二块区域
- 如果生成的随机数是10,那么落到第三块区域
代码如下:
public class WeightRandom { static Servers servers = new Servers(); static Random random = new Random(); public static String go() { int allWeight = servers.map.values().stream().mapToInt(a -> a).sum(); var number = random.nextInt(allWeight); for (var item : servers.map.entrySet()) { if (item.getValue() >= number) { return item.getKey(); } number -= item.getValue(); } return ""; } public static void main(String[] args) { for (var i = 0; i < 15; i++) { System.out.println(go()); } } } 复制代码
运行结果:
这种实现方式虽然相对第一种实现方式比较“绕”,但却是一种比较好的实现方式, 对内存没有浪费,权重大小和服务器List的Size也没有关系。
轮询
轮询又分为三种,1.完全轮询 2.加权轮询 3.平滑加权轮询
完全轮询
public class FullRound { static Servers servers = new Servers(); static int index; public static String go() { if (index == servers.list.size()) { index = 0; } return servers.list.get(index++); } public static void main(String[] args) { for (var i = 0; i < 15; i++) { System.out.println(go()); } } } 复制代码
运行结果:
完全轮询,也是比较简单的,但是问题和完全随机是一样的,所以出现了加权轮询。
加权轮询
加权轮询还是有两种常用的实现方式,和加权随机是一样的,在这里,我就演示我认为比较好的一种:
public class WeightRound { static Servers servers = new Servers(); static int index; public static String go() { int allWeight = servers.map.values().stream().mapToInt(a -> a).sum(); int number = (index++) % allWeight; for (var item : servers.map.entrySet()) { if (item.getValue() > number) { return item.getKey(); } number -= item.getValue(); } return ""; } public static void main(String[] args) { for (var i = 0; i < 15; i++) { System.out.println(go()); } } } 复制代码
运行结果:
加权轮询,看起来并没什么问题,但是还是有一点瑕疵,其中一台服务器的压力可能会突然上升,而另外的服务器却很“悠闲,喝着咖啡,看着新闻”。我们希望虽然是按照轮询,但是中间最好可以有交叉,所以出现了第三种轮询算法:平滑加权轮询。
平滑加权轮询
平滑加权是一个算法,很神奇的算法,我们有必要先对这个算法进行讲解。 比如A服务器的权重是5,B服务器的权重是1,C服务器的权重是1。 这个权重,我们称之为“固定权重”,既然这个叫“固定权重”,那么肯定还有叫“非固定权重的”,没错,“非固定权重”每次都会根据一定的规则变动。
- 第一次访问,ABC的“非固定权重”分别是 5 1 1(初始),因为5是其中最大的,5对应的就是A服务器,所以这次选到的服务器就是A,然后我们用当前被选中的服务器的权重-各个服务器的权重之和,也就是A服务器的权重-各个服务器的权重之和。也就是5-7=-2,没被选中的服务器的“非固定权重”不做变化,现在三台服务器的“非固定权重”分别是-2 1 1。
- 第二次访问,把第一次访问最后得到的“非固定权重”+“固定权重”,现在三台服务器的“非固定权重”是3,2,2,因为3是其中最大的,3对应的就是A服务器,所以这次选到的服务器就是A,然后我们用当前被选中的服务器的权重-各个服务器的权重之和,也就是A服务器的权重-各个服务器的权重之和。也就是3-7=-4,没被选中的服务器的“非固定权重”不做变化,现在三台服务器的“非固定权重”分别是-4 1 1。
- 第三次访问,把第二次访问最后得到的“非固定权重”+“固定权重”,现在三台服务器的“非固定权重”是1,3,3,这个时候3虽然是最大的,但是却出现了两个,我们选第一个,第一个3对应的就是B服务器,所以这次选到的服务器就是B,然后我们用当前被选中的服务器的权重-各个服务器的权重之和,也就是B服务器的权重-各个服务器的权重之和。也就是3-7=-4,没被选中的服务器的“非固定权重”不做变化,现在三台服务器的“非固定权重”分别是1 -4 3。 ... 以此类推,最终得到这样的表格:
请求 | 获得服务器前的非固定权重 | 选中的服务器 | 获得服务器后的非固定权重 |
---|---|---|---|
1 | {5, 1, 1} | A | {-2, 1, 1} |
2 | {3, 2, 2} | A | {-4, 2, 2} |
3 | {1, 3, 3} | B | {1, -4, 3} |
4 | {6, -3, 4} | A | {-1, -3, 4} |
5 | {4, -2, 5} | C | {4, -2, -2} |
6 | {9, -1, -1} | A | {2, -1, -1} |
7 | {7, 0, 0} | A | {0, 0, 0} |
8 | {5, 1, 1} | A | {-2, 1, 1} |
当第8次的时候,“非固定权重“又回到了初始的5 1 1,是不是很神奇,也许算法还是比较绕的,但是代码却简单多了:
public class Server { public Server(int weight, int currentWeight, String ip) { this.weight = weight; this.currentWeight = currentWeight; this.ip = ip; } private int weight; private int currentWeight; private String ip; public int getWeight() { return weight; } public void setWeight(int weight) { this.weight = weight; } public int getCurrentWeight() { return currentWeight; } public void setCurrentWeight(int currentWeight) { this.currentWeight = currentWeight; } public String getIp() { return ip; } public void setIp(String ip) { this.ip = ip; } } 复制代码
public class Servers { public HashMap<String, Server> serverMap = new HashMap<>() { { put("192.168.1.1", new Server(5,5,"192.168.1.1")); put("192.168.1.2", new Server(1,1,"192.168.1.2")); put("192.168.1.3", new Server(1,1,"192.168.1.3")); } }; } 复制代码
public class SmoothWeightRound { private static Servers servers = new Servers(); public static String go() { Server maxWeightServer = null; int allWeight = servers.serverMap.values().stream().mapToInt(Server::getWeight).sum(); for (Map.Entry<String, Server> item : servers.serverMap.entrySet()) { var currentServer = item.getValue(); if (maxWeightServer == null || currentServer.getCurrentWeight() > maxWeightServer.getCurrentWeight()) { maxWeightServer = currentServer; } } assert maxWeightServer != null; maxWeightServer.setCurrentWeight(maxWeightServer.getCurrentWeight() - allWeight); for (Map.Entry<String, Server> item : servers.serverMap.entrySet()) { var currentServer = item.getValue(); currentServer.setCurrentWeight(currentServer.getCurrentWeight() + currentServer.getWeight()); } return maxWeightServer.getIp(); } public static void main(String[] args) { for (var i = 0; i < 15; i++) { System.out.println(go()); } } } 复制代码
运行结果:
这就是平滑加权轮询,巧妙的利用了巧妙算法,既有轮询的效果,又避免了某台服务器压力突然升高,不可谓不妙。
哈希
负载均衡算法中的哈希算法,就是根据某个值生成一个哈希值,然后对应到某台服务器上去,当然可以根据用户,也可以根据请求参数,或者根据其他,想怎么来就怎么来。如果根据用户,就比较巧妙的解决了负载均衡下Session共享的问题,用户小明走的永远是A服务器,用户小笨永远走的是B服务器。
那么如何用代码实现呢,这里又需要引出一个新的概念: 哈希环 。
什么?我只听过奥运五环,还有“啊 五环 你比四环多一环,啊 五环 你比六环少一环”,这个哈希环又是什么鬼?容我慢慢道来。
哈希环,就是一个环!这...好像...有点难解释呀,我们还是画图来说明把。
一个圆是由无数个点组成的,这是最简单的数学知识,相信大家都可以理解吧,哈希环也一样,哈希环也是有无数个“哈希点”构成的,当然并没有“哈希点”这样的说法,只是为了便于大家理解。
我们先计算出服务器的哈希值,比如根据IP,然后把这个哈希值放到环里,如上图所示。
来了一个请求,我们再根据某个值进行哈希,如果计算出来的哈希值落到了A和B的中间,那么按照顺时针算法,这个请求给B服务器。
理想很丰满,现实很孤单,可能三台服务器掌管的“区域”大小相差很大很大,或者干脆其中一台服务器坏了,会出现如下的情况:
可以看出,B掌管的“区域”实在是太大,A可以说是“很悠闲,喝着咖啡,看着电影”,像这种情况,就叫“ 哈希倾斜 ”。
那么怎么避免这种情况呢? 虚拟节点 。
什么是虚拟节点呢,说白了,就是虚拟的节点...好像..没解释啊...还是上一张丑到爆炸的图吧:
其中,正方形的是真实的节点,或者说真实的服务器,五边形的是虚拟节点,或者说是虚拟的服务器,当一个请求过来,落到了A1和B1之间,那么按照顺时针的规则,应该由B1服务器进行处理,但是B1服务器是虚拟的,它是从B服务器映射出来的,所以再交给B服务器进行处理。
要实现此种负载均衡算法,需要用到一个平时不怎么常用的Map:TreeMap,对TreeMap不了解的朋友可以先去了解下TreeMap,下面放出代码:
private static String go(String client) { int nodeCount = 20; TreeMap<Integer, String> treeMap = new TreeMap(); for (String s : new Servers().list) { for (int i = 0; i < nodeCount; i++) treeMap.put((s + "--服务器---" + i).hashCode(), s); } int clientHash = client.hashCode(); SortedMap<Integer, String> subMap = treeMap.tailMap(clientHash); Integer firstHash; if (subMap.size() > 0) { firstHash = subMap.firstKey(); } else { firstHash = treeMap.firstKey(); } String s = treeMap.get(firstHash); return s; } public static void main(String[] args) { System.out.println(go("今天天气不错啊")); System.out.println(go("192.168.5.258")); System.out.println(go("0")); System.out.println(go("-110000")); System.out.println(go("风雨交加")); } 复制代码
运行结果:
哈希负载均衡算法到这里就结束了。
最小压力
所以的最小压力负载均衡算法就是 选择一台当前最“悠闲”的服务器,如果A服务器有100个请求,B服务器有5个请求,而C服务器只有3个请求,那么毫无疑问会选择C服务器,这种负载均衡算法是比较科学的。但是遗憾的在当前的场景下无法模拟出来“原汁原味”的最小压力负载均衡算法的。
当然在实际的负载均衡下,可能会将多个负载均衡算法合在一起实现,比如先根据最小压力算法,当有几台服务器的压力一样小的时候,再根据权重取出一台服务器,如果权重也一样,再随机取一台,等等。
今天的内容到这里就结束了,谢谢大家。
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网
猜你喜欢:本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。
JAVA语言规范(英文版,第3版)
戈斯林 / 机械工业 / 2006-4 / 79.00元
本书由“java之父”Jame Gosling 以及另外三位顶级大师撰写而成,无论是对java语言的初学者还是专业程序员都具有极高的价值,是关于java程序设计语言最权威的技术参考书。 本书侧重于java技术细节和内幕,全面,准确,详尽地介绍了java语言及其语法,论述了java编译器所要检查的语法和java运行模式的各个方面,同时还描述了java语言最重要的新特征。一起来看看 《JAVA语言规范(英文版,第3版)》 这本书的介绍吧!