澳门新浦京娱乐游戏6种负载均衡算法

澳门新浦京娱乐游戏 1

第一给大家介绍下怎么样是负载均衡(来自百科)

转自:

负载均衡
建设布局在存活网络结构如上,它提供了一种廉价有效透明的法子扩充 网络设施和 服务器的带宽、扩展 吞吐量、抓牢网络数据管理才能、提升网络的狡猾和可用性。

什么样是负载均衡

负载均衡,斯洛伐克语名叫Load
Balance,其意思就是分摊到三个操作单元上实行执行,举个例子Web 服务器、 FTP服务器、 公司根本应用服务器和其他主要任务服务器等,进而协同达成专门的学问任务。

负载均衡,希伯来语名为Load
Balance,指由多台服务器以对称的点子组成一个服务器会集,每台服务器都负有格外的身价,都足以独立对外提供劳务而无须别的服务器的接济。通过某种负载分担本事,将表面发送来的央浼均匀分配到对称构造中的某一台服务器上,而选用到诉求的服务器独立地回答顾客的央浼。负载均衡可以平均分配客商诉求到服务器阵列,借此提供便捷取得主要数据,消逝大气面世访问服务难题,这种集群技能能够用起码的投资赢得接近于大型主机的性质。

澳门新浦京娱乐游戏 1

负载均衡分为软件负载均衡和硬件负载均衡,后边三个的象征是Ali章文嵩大学生研究开发的LVS,前面一个则是平均服务器例如F5,当然那只是提一下,不是首要。

正文陈诉的是”将表面发送来的央求均匀分配到对称构造中的某一台服务器上”的各类算法,并以Java代码演示各样算法的切切实实贯彻,OK,上面步入正题,在步入正题前,先写贰个类来模拟Ip列表:

本文陈说的是”将表面发送来的号召均匀分配到对称结构中的某一台服务器上“的各类算法,并以Java代码演示每一个算法的求实落实,OK,上边进入正题,在步入正题前,先写叁个类来效仿Ip列表:

import java.util.HashMap;

/**
 * @author ashang.peng@aliyun.com
 * @date 二月 07, 2017
 */

public class IpMap   {
    // 待路由的Ip列表,Key代表Ip,Value代表该Ip的权重
    public static HashMap<String, Integer> serverWeightMap =
            new HashMap<String, Integer>();

    static
    {
        serverWeightMap.put("192.168.1.100", 1);
        serverWeightMap.put("192.168.1.101", 1);
        // 权重为4
        serverWeightMap.put("192.168.1.102", 4);
        serverWeightMap.put("192.168.1.103", 1);
        serverWeightMap.put("192.168.1.104", 1);
        // 权重为3
        serverWeightMap.put("192.168.1.105", 3);
        serverWeightMap.put("192.168.1.106", 1);
        // 权重为2
        serverWeightMap.put("192.168.1.107", 2);
        serverWeightMap.put("192.168.1.108", 1);
        serverWeightMap.put("192.168.1.109", 1);
        serverWeightMap.put("192.168.1.110", 1);
    }
}

澳门新浦京娱乐游戏 2

轮询(Round Robin)法

轮询调治算法的原理是每叁次把来自顾客的乞请更迭分配给内部中的服务器,从1最初,直到N(内部服务器个数卡塔尔国,然后重新最先循环。算法的优点是其简洁性,它没有须求记下当前怀有连接的气象,所以它是一种无状态调解。

其代码达成大概如下:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * @author ashang.peng@aliyun.com
 * @date 二月 07, 2017
 */

class RoundRobin   {
    private static Integer pos = 0;

    public static String getServer()
    {
        // 重建一个Map,避免服务器的上下线导致的并发问题
        Map<String, Integer> serverMap =
                new HashMap<String, Integer>();
        serverMap.putAll(IpMap.serverWeightMap);

        // 取得Ip地址List
        Set<String> keySet = serverMap.keySet();
        ArrayList<String> keyList = new ArrayList<String>();
        keyList.addAll(keySet);

        String server = null;
        synchronized (pos)
        {
            if (pos > keySet.size())
                pos = 0;
            server = keyList.get(pos);
            pos ++;
        }

        return server;
    }
}

是因为serverWeightMap中的地址列表是动态的,任何时候大概有机械上线、下线可能宕机,由此为了幸免可能现身的产出问题,方法内部要新建局地变量serverMap,现将serverMap中的内容复制到线程本地,防止止被多个线程改革。那样只怕会引进新的标题,复制现在serverWeightMap的改过无法体现给serverMap,也正是说这一轮选拔服务器的进度中,新添服务器或然下线服务器,负载均衡算法将无法获悉。新增添无所谓,假若有服务器下线或然宕机,那么大概会拜会到不设有的地址。由此,服务调用端需求有对应的容错管理,比如重新发起叁回server接受并调用。

对于当下轮询的任务变量pos,为了保险服务器接收的顺序性,要求在操作时对其加锁,使得同样时刻只可以有一个线程可以改革pos的值,不然当pos变量被冒出校勘,则无从担保服务器选取的顺序性,以至有极大大概导致keyList数组越界。

轮询法的长处在于:试图落成诉求改造的断然均衡。

轮询法的败笔在于:为了形成央求修改的绝对化均衡,必得付出一点都超大的代价,因为为了保证pos变量改正的互斥性,供给引进重量级的消极锁synchronized,那将会促成该段轮询代码的现身吞吐量发生生硬的下挫。

 1 public class IpMap
 2 {
 3     // 待路由的Ip列表,Key代表Ip,Value代表该Ip的权重
 4     public static HashMap<String, Integer> serverWeightMap = 
 5             new HashMap<String, Integer>();
 6     
 7     static
 8     {
 9         serverWeightMap.put("192.168.1.100", 1);
10         serverWeightMap.put("192.168.1.101", 1);
11         // 权重为4
12         serverWeightMap.put("192.168.1.102", 4);
13         serverWeightMap.put("192.168.1.103", 1);
14         serverWeightMap.put("192.168.1.104", 1);
15         // 权重为3
16         serverWeightMap.put("192.168.1.105", 3);
17         serverWeightMap.put("192.168.1.106", 1);
18         // 权重为2
19         serverWeightMap.put("192.168.1.107", 2);
20         serverWeightMap.put("192.168.1.108", 1);
21         serverWeightMap.put("192.168.1.109", 1);
22         serverWeightMap.put("192.168.1.110", 1);
23     }
24 }

随机(Random)法

通过系统的自便算法,依照后端服务器的列表大小值来随意选拔在那之中的一台服务器实行访谈。由可能率总括理论能够查出,随着客商端调用服务端的次数加多,

其实际效果越来越贴近于平均分配调用量到后端的每一台服务器,相当于轮询的结果。

随机法的代码完毕大概如下:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * @author ashang.peng@aliyun.com
 * @date 二月 07, 2017
 */

 class Random   {
    public static String getServer()
    {
        // 重建一个Map,避免服务器的上下线导致的并发问题   
        Map<String, Integer> serverMap =
                new HashMap<String, Integer>();
        serverMap.putAll(IpMap.serverWeightMap);

        // 取得Ip地址List   
        Set<String> keySet = serverMap.keySet();
        ArrayList<String> keyList = new ArrayList<String>();
        keyList.addAll(keySet);

        java.util.Random random = new java.util.Random();
        int randomPos = random.nextInt(keyList.size());

        return keyList.get(randomPos);
    }
}

全体代码思路和轮询法一致,先重新建立serverMap,再拿走到server列表。在增选server的时候,通过Random的nextInt方法取0~keyList.size(卡塔尔(قطر‎区间的二个放肆值,进而从服务器列表中私行取得到一台服务器地址进行重返。基于概率计算的批驳,吞吐量越大,随机算法的效能越临近于轮询算法的效应。

澳门新浦京娱乐游戏 3

源地址哈希(Hash)法

源地址哈希的理念是依靠获得顾客端的IP地址,通过哈希函数总结获得的一个数值,用该数值对服务器列表的大小进行取模运算,获得的结果就是客服端要寻访服务器的序号。接收源地址哈希法进行负荷均衡,同一IP地址的客商端,当后端服务器列表不改变时,它每一回都会粲焕到同一台后端服务器进行访谈。

源地址哈希算法的代码达成大致如下:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * @author ashang.peng@aliyun.com
 * @date 二月 07, 2017
 */

 class Hash      {
    public static String getServer()
    {
        // 重建一个Map,避免服务器的上下线导致的并发问题
        Map<String, Integer> serverMap =
                new HashMap<String, Integer>();
        serverMap.putAll(IpMap.serverWeightMap);

        // 取得Ip地址List
        Set<String> keySet = serverMap.keySet();
        ArrayList<String> keyList = new ArrayList<String>();
        keyList.addAll(keySet);

        // 在Web应用中可通过HttpServlet的getRemoteIp方法获取
        String remoteIp = "127.0.0.1";
        int hashCode = remoteIp.hashCode();
        int serverListSize = keyList.size();
        int serverPos = hashCode % serverListSize;

        return keyList.get(serverPos);
    }
}

前两有的和轮询法、随机法相似就不说了,差异在于路由精选部分。通过顾客端的ip也正是remoteIp,获得它的Hash值,对服务器列表的轻重缓急取模,结果正是选拔的服务器在服务器列表中的索引值。

源地址哈希法的独特之处在于:保险了同一顾客端IP地址将会被哈希到同一台后端服务器,直到后端服务器列表改造。遵照此天性能够在劳务消费者与劳务提供者之间确立有情状的session会话。

源地址哈希算法的劣势在于:除非集群中服务器的十二分稳固,基本不会上下线,否则一经有服务器上线、下线,那么通过源地址哈希算法路由到的服务器是服务器上线、下线前路由到的服务器的票房价值相当低,要是是session则取不到session,借使是缓存则大概引发”雪崩”。假使这么解释不相符精通,可以看小编事情发生前的一篇小说MemCache超详细解读,一致性Hash算法部分。

 

加权轮询(Weight Round 罗布in)法

昨今分化的后端服务器大概机器的布置和当下系统的载重并差异,由此它们的抗压技巧也不等同。给配备高、负载低的机器配置更加高的权重,让其拍卖越来越多的请;而布署低、负载高的机械,给其分配非常的低的权重,裁减其系统负荷,加权轮询能很好地管理这一主题素材,并将呼吁顺序且依据权重分配到后端。加权轮询法的代码实现大约如下:

import java.util.*;

/**
 * @author ashang.peng@aliyun.com
 * @date 二月 07, 2017
 */
class WeightRoundRobin   {
    private static Integer pos;

    public static String getServer()
    {
        // 重建一个Map,避免服务器的上下线导致的并发问题
        Map<String, Integer> serverMap =
                new HashMap<String, Integer>();
        serverMap.putAll(IpMap.serverWeightMap);

        // 取得Ip地址List
        Set<String> keySet = serverMap.keySet();
        Iterator<String> iterator = keySet.iterator();

        List<String> serverList = new ArrayList<String>();
        while (iterator.hasNext())
        {
            String server = iterator.next();
            int weight = serverMap.get(server);
            for (int i = 0; i < weight; i++)
                serverList.add(server);
        }

        String server = null;
        synchronized (pos)
        {
            if (pos > keySet.size())
                pos = 0;
            server = serverList.get(pos);
            pos ++;
        }

        return server;
    }
}

与轮询法近似,只是在收获服务器地址以前增添了一段权重总计的代码,根据权重的轻重,将地点重复地加多到服务器地址列表中,权重越大,该服务器每轮所得到的央浼数量越多。

轮询(Round Robin)法

加权随机(Weight Random)法

与加权轮询法相仿,加权随机法也依据后端机器的布署,系统的载荷分配区别的权重。区别的是,它是依照权重随机央求后端服务器,而非顺序。

import java.util.*;

/**
 * @author ashang.peng@aliyun.com
 * @date 二月 07, 2017
 */

 class WeightRandom   {
    public static String getServer()
    {
        // 重建一个Map,避免服务器的上下线导致的并发问题
        Map<String, Integer> serverMap =
                new HashMap<String, Integer>();
        serverMap.putAll(IpMap.serverWeightMap);

        // 取得Ip地址List
        Set<String> keySet = serverMap.keySet();
        Iterator<String> iterator = keySet.iterator();

        List<String> serverList = new ArrayList<String>();
        while (iterator.hasNext())
        {
            String server = iterator.next();
            int weight = serverMap.get(server);
            for (int i = 0; i < weight; i++)
                serverList.add(server);
        }

        java.util.Random random = new java.util.Random();
        int randomPos = random.nextInt(serverList.size());

        return serverList.get(randomPos);
    }
}

这段代码约等于是随机法和加权轮询法的组成,比较好驾驭,就不表明了。

轮询法即Round 罗布in法,其代码落成大致如下:

小小的连接数(Least Connections)法

小小连接数算法比较灵敏和智能,由于后端服务器的陈设不尽相符,对于伏乞的拍卖有快有慢,它是依赖后端服务器当前的总是情形,动态地筛选个中当前

积压连接数起码的一台服务器来管理当下的央浼,尽大概地抓实后端服务的利用效用,将担任合理地分流到每一台服务器。

前边二种方法久有存心来促成服务消费者须求次数分配的平均,当然如此做是对的的,可认为后端的多台服务器平均分配专门的学问量,最大程度地进步服务器的利用率,可是事实上情况是或不是真的这么?实际意况中,央求次数的均衡真的能代表负载的人均吗?那是三个值得寻思的难题。

上面的标题,再换多少个角度来讲便是:未来端服务器的见解来寓目系统的载荷,而非央浼发起方来察看。最小连接数法便归属此类。

小小连接数算法比较灵活和智能,由于后端服务器的配置不尽相近,对于必要的拍卖有快有慢,它就是根据后端服务器当前的接连几天情状,动态地选拔当中当前积压连接数最少的一台服务器来处理当下恳请,尽大概地升高后端服务器的利用功效,将负载合理地分流到每一台机械。由于细小连接数设计服务器连接数的集聚和感知,设计与落实相比较麻烦,此处就蒙蔽它的达成了。

附了几个验证“NGINX的贯彻原因,大家能够看看”:blog.csdn.net

澳门新浦京娱乐游戏 4

 1 public class RoundRobin
 2 {
 3     private static Integer pos = 0;
 4     
 5     public static String getServer()
 6     {
 7         // 重建一个Map,避免服务器的上下线导致的并发问题
 8         Map<String, Integer> serverMap = 
 9                 new HashMap<String, Integer>();
10         serverMap.putAll(IpMap.serverWeightMap);
11         
12         // 取得Ip地址List
13         Set<String> keySet = serverMap.keySet();
14         ArrayList<String> keyList = new ArrayList<String>();
15         keyList.addAll(keySet);
16         
17         String server = null;
18         synchronized (pos)
19         {
20             if (pos > keySet.size())
21                 pos = 0;
22             server = keyList.get(pos);
23             pos ++;
24         }
25         
26         return server;
27     }
28 }

澳门新浦京娱乐游戏 5

出于serverWeightMap中的地址列表是动态的,随即只怕有机械上线、下线只怕宕机,由此为了幸免可能现身的面世难点,方法内部要新建局地变量serverMap,现将serverMap中的内容复制到线程本地,以幸免被四个线程修改。那样大概会引进新的难题,复制未来serverWeightMap的更改无法反映给serverMap,也正是说这一轮采用服务器的历程中,新增加服务器大概下线服务器,负载均衡算法将不可能获悉。新添不留意,尽管有服务器下线可能宕机,那么大概会访谈到荒诞不经的地点。由此,劳务调用端须求有相应的容错管理,举个例子重新发起一回server选取并调用

对此日前轮询的岗位变量pos,为了确定保证服务器采取的顺序性,需求在操作时对其加锁,使得同不经常刻只好有一个线程能够修改pos的值,不然当pos变量被冒出改过,则无从作保服务器采纳的顺序性,以至有极大恐怕引致keyList数组越界。

轮询法的独特之处在于:试图实现诉求改变的相对化均衡

轮询法的缺欠在于:为了成功要求改变的相对均衡,必需交给一定大的代价,因为为了确定保障pos变量改善的互斥性,供给引进重量级的消极锁synchronized,那将会导致该段轮询代码的面世吞吐量产生明确的骤降

 

随机(Random)法

因此系统随机函数,按照后端服务器列表的大小值来随便筛选此中一台举行访谈。由可能率总括理论能够查出,随着调用量的增大,其实效更加的接近于平均分配流量到每一台后端服务器,也正是轮询的功效。

随机法的代码达成大概如下:

澳门新浦京娱乐游戏 6

 1 public class Random
 2 {
 3     public static String getServer()
 4     {
 5         // 重建一个Map,避免服务器的上下线导致的并发问题
 6         Map<String, Integer> serverMap = 
 7                 new HashMap<String, Integer>();
 8         serverMap.putAll(IpMap.serverWeightMap);
 9         
10         // 取得Ip地址List
11         Set<String> keySet = serverMap.keySet();
12         ArrayList<String> keyList = new ArrayList<String>();
13         keyList.addAll(keySet);
14         
15         java.util.Random random = new java.util.Random();
16         int randomPos = random.nextInt(keyList.size());
17         
18         return keyList.get(randomPos);
19     }
20 }

澳门新浦京娱乐游戏 7

完全代码思路和轮询法一致,先重新建立serverMap,再获得到server列表。在选择server的时候,通过Random的nextInt方法取0~keyList.size(卡塔尔区间的三个无约束值,进而从服务器列表中大肆获得到一台服务器地址进行重临。依据概率总结的争鸣,吞吐量越大,随机算法的效用越接近于轮询算法的成效

 

源地址哈希(Hash)法

源地址哈希的构思是收获顾客端访问的IP地址值,通过哈希函数计算得到三个数值,用该数值对服务器列表的分寸进行取模运算,取得的结果便是要拜访的服务器的序号。源地址哈希算法的代码达成大概如下:

澳门新浦京娱乐游戏 8

 1 public class Hash
 2 {
 3     public static String getServer()
 4     {
 5         // 重建一个Map,避免服务器的上下线导致的并发问题
 6         Map<String, Integer> serverMap = 
 7                 new HashMap<String, Integer>();
 8         serverMap.putAll(IpMap.serverWeightMap);
 9         
10         // 取得Ip地址List
11         Set<String> keySet = serverMap.keySet();
12         ArrayList<String> keyList = new ArrayList<String>();
13         keyList.addAll(keySet);
14         
15         // 在Web应用中可通过HttpServlet的getRemoteIp方法获取
16         String remoteIp = "127.0.0.1";
17         int hashCode = remoteIp.hashCode();
18         int serverListSize = keyList.size();
19         int serverPos = hashCode % serverListSize;
20         
21         return keyList.get(serverPos);
22     }
23 }

澳门新浦京娱乐游戏 9

前两有的和轮询法、随机法相近就遮掩了,差距在于路由精选部分。通过顾客端的ip也即是remoteIp,得到它的Hash值,对服务器列表的尺寸取模,结果便是选拔的服务器在服务器列表中的索引值。

源地址哈希法的独特的地方在于:保证了同出一辙客商端IP地址将会被哈希到同一台后端服务器,直到后端服务器列表退换。依照此个性能够在服务消费者与劳务提供者之间确立有景况的session会话

源地址哈希算法的破绽在于:除非集群中服务器的特别安静,基本不会上下线,不然一经有服务器上线、下线,那么通过源地址哈希算法路由到的服务器是服务器上线、下线前路由到的服务器的可能率十分低,假如是session则取不到session,假若是缓存则可能引发”雪崩”。借使这么解释不相符精通,可以看本身事情发生前的一篇文章MemCache超详细解读,一致性Hash算法部分。

 

加权轮询(Weight Round Robin)法

不一致的服务器可能机器配置和近期系统的载荷并差别,由此它们的抗压技巧也不尽相符,给配置高、负载低的机器配置更加高的权重,让其拍卖越来越多的央求,而低配置、高负载的机器,则给其分配十分低的权重,裁减其系统负荷。加权轮询法能够很好地拍卖这一难题,并将号召顺序根据权重分配到后端。加权轮询法的代码落成大概如下:

澳门新浦京娱乐游戏 10

 1 public class WeightRoundRobin
 2 {
 3     private static Integer pos;
 4     
 5     public static String getServer()
 6     {
 7         // 重建一个Map,避免服务器的上下线导致的并发问题
 8         Map<String, Integer> serverMap = 
 9                 new HashMap<String, Integer>();
10         serverMap.putAll(IpMap.serverWeightMap);
11         
12         // 取得Ip地址List
13         Set<String> keySet = serverMap.keySet();
14         Iterator<String> iterator = keySet.iterator();
15         
16         List<String> serverList = new ArrayList<String>();
17         while (iterator.hasNext())
18         {
19             String server = iterator.next();
20             int weight = serverMap.get(server);
21             for (int i = 0; i < weight; i++)
22                 serverList.add(server);
23         }
24         
25         String server = null;
26         synchronized (pos)
27         {
28             if (pos > keySet.size())
29                 pos = 0;
30             server = serverList.get(pos);
31             pos ++;
32         }
33         
34         return server;
35     }
36 }

澳门新浦京娱乐游戏 11

与轮询法相仿,只是在获取服务器地址早前增添了一段权重计算的代码,依照权重的尺寸,将地点重复地充实到服务器地址列表中,权重越大,该服务器每轮所获得的乞求数量越来越多。

 

加权随机(Weight Random)法

与加权轮询法相像,加权随机法也是依靠后端服务器分化的安顿和负载情形来架构差异的权重。不相同的是,它是信守权重来随意选择服务器的,实际不是逐个。加权随机法的代码实现如下:

澳门新浦京娱乐游戏 12

 1 public class WeightRandom
 2 {
 3     public static String getServer()
 4     {
 5         // 重建一个Map,避免服务器的上下线导致的并发问题
 6         Map<String, Integer> serverMap = 
 7                 new HashMap<String, Integer>();
 8         serverMap.putAll(IpMap.serverWeightMap);
 9         
10         // 取得Ip地址List
11         Set<String> keySet = serverMap.keySet();
12         Iterator<String> iterator = keySet.iterator();
13         
14         List<String> serverList = new ArrayList<String>();
15         while (iterator.hasNext())
16         {
17             String server = iterator.next();
18             int weight = serverMap.get(server);
19             for (int i = 0; i < weight; i++)
20                 serverList.add(server);
21         }
22         
23         java.util.Random random = new java.util.Random();
24         int randomPos = random.nextInt(serverList.size());
25         
26         return serverList.get(randomPos);
27     }
28 }

澳门新浦京娱乐游戏 13

这段代码相当于是随机法和加权轮询法的整合,比较好精晓,就不解释了。

 

小小连接数(Least Connections)法

前边二种方法冥思苦想来实现劳务消费者须要次数分配的均衡,当然如此做是没有错的,可感觉后端的多台服务器平均分配专门的职业量,最大程度地巩固服务器的利用率,然而实际上意况是不是真正这么?实际情状中,诉求次数的均衡真的能表示负载的均衡吗?那是二个值得沉凝的主题素材。

地点的标题,再换三个角度来讲便是:事后端服务器的见地来侦查系统的载荷,而非乞请发起方来观看。最小连接数法便归于此类。

小小连接数算法相比灵活和智能,由于后端服务器的安插不尽相像,对于央求的管理有快有慢,它就是依据后端服务器当前的接连情形,动态地筛选在那之中当前积压连接数最少的一台服务器来拍卖当下倡议,尽也许地抓牢后端服务器的利用效用,将负载合理地分流到每一台机器。由于纤维连接数设计服务器连接数的汇总和感知,设计与实现比较麻烦,此处就背着它的落到实处了。

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图