array负载均衡密码

转载

mob64ca13fe1aa6 2024-09-14 06:23:45

文章标签 array负载均衡密码服务器权重负载均衡 文章分类 运维

一.负载均衡介绍

1.什么是负载均衡?

用户->负载均衡平衡器->多台服务器(一个集群下) 负载均衡就是负载均衡器中实现的算法或者硬件设施.同时解决大量并发访问服务器问题.

2.负载均衡的方式?

软件负载均衡:Nginx.LVS,HAProxy

硬件负载均衡:Arrays,F5

3.负载均衡算法

//正常分配
	public static final List<String> 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"  //这一台性能高
    );
	//考虑权重
    public static final Map<String,Integer> WEIGHT_MAP = new LinkedHashMap<>();
    static {
        WEIGHT_MAP.put("192.168.0.1",2);
        WEIGHT_MAP.put("192.168.0.2",8);
        WEIGHT_MAP.put("192.168.0.3",1);
        WEIGHT_MAP.put("192.168.0.4",9);
        WEIGHT_MAP.put("192.168.0.5",4);
        WEIGHT_MAP.put("192.168.0.6",6);
    }

3.1随机算法

1.正常随机

public static String getServer() {
        Random random = new Random();
        return ClentTest.LIST.get(random.nextInt(ClentTest.LIST.size()));s
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(getServer());s
        }
    }

2.ip + 权重系数

public static String getServer() {
        List<String> ips = new ArrayList<>();
        ClentTest.WEIGHT_MAP.keySet().stream().forEach(ip -> {
            Integer weight = ClentTest.WEIGHT_MAP.get(ip);
            for (int i = 0; i < weight; i++) {
                ips.add(ip);
            }
        });
        Random random = new Random();
        return ClentTest.LIST.get(random.nextInt(ClentTest.LIST.size()));

    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(getServer());
        }
    }

3.随机分配理解和改进

A服务器权重系数为5 也是服务器调用的次数

B 为 3

C 为 2

看作数组为[5,3,2],看作定点长 5+3+2 = 10 权重总和

0-----5—8–10

A B C 服务器所在位置

1.假设一个随机数offest = 7;随机0-5则取A,5-8则取B,8-10则取C,但是0-5的距离长所以占权重也多.

2.因为随机是7所以定点落在A-B上.

offest > 5; offest = offest - 5; offest = 2;

定点坐标改变为 0—3–5 :因为减去了5

offest < 3;return B; 减去的步骤是将A服务器排除,同时offest一定要比服务器数值小.

public static String getServer() {
        //流计算整数和
        int totalWeight = ClentTest.WEIGHT_MAP.values().stream().mapToInt(weight -> weight).sum();
        //System.out.println(totalWeight);
        int offest = new Random().nextInt(totalWeight);
        for (String ip : ClentTest.WEIGHT_MAP.keySet()) {
            Integer weight = ClentTest.WEIGHT_MAP.get(ip);
            if (offest < weight) {
                return ip;
            }
            offest = offest - weight;
        }
        Random random = new Random();
        return ClentTest.LIST.get(random.nextInt(ClentTest.LIST.size()));

    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(getServer());
        }
    }

3.2轮询算法

1.正常实现

private static Integer pos = 0; //轮询下标
    public static String getServer() {
        if (pos >= ClentTest.LIST.size()) {
            pos = 0;
        }
        String ip = ClentTest.LIST.get(pos);
        pos ++;
        return ip;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            System.out.println(getServer());
        }
    }

2.考虑权重去实现

假设offest = 1,2,3,4,5,…有规律的递增的轮询,也可以通过上述实现(递增的范围跟服务器的权重总和有关)

A服务器权重系数为5 也是服务器调用的次数

B 为 3

C 为 2

offest > 5; offest = offest - 5; offest = 2;

offest < 3;return B;

则出现: AAAAABBBCC

同时我们可以得出上述逻辑根据offest的结果不同则产生的影响也不同,在轮询随机中都可以采用这种算法

我们实现轮询可以根据requestID(主键递增的),如果ID到达1000,1001…

//requestID的生成
	public static Integer num = 0;
    public static Integer getAndIncrement() {
        return num++;
    }

1.我们采用%实现

public static String getServer() {
        int totalWeight = 0;
        for (Integer weight : ClentTest.WEIGHT_MAP.values()) {
            totalWeight += weight;
        }
        int requestID = RequestID.getAndIncrement(); //0--10000
        int offset = requestID % totalWeight;
        for (String ip : ClentTest.WEIGHT_MAP.keySet()) {
            Integer weight = ClentTest.WEIGHT_MAP.get(ip);

            if (offset < weight) {
                return ip;
            }

            offset = offset - weight;
        }

        return null;

    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            System.out.println(getServer());
        }
    }

这样实现产生问题:如果

A服务器权重系数为5 也是服务器调用的次数

B 为 1

C 为 1

则产生AAAAABC,但是采用平衡加权轮询算法则可以产生AABACAA,可以使得某时刻A服务器的压力不是那么大

问题:那么轮询之后还是会使得A服务器上压力过大?

2.平衡加权轮询算法(Nginx中默认采用的)

array负载均衡密码_服务器

同时他的结果也很平滑 AABACAA

class Weight {
    private String ip;
    private Integer weight;
    private Integer currentWeight;
}

/**
     * 平衡加权轮询算法实现
     */
    private static Map<String,Weight> weightMap = new LinkedHashMap<>();
    public static String getServer() {

        if (weightMap.isEmpty()) {
            for (String ip : ClentTest.WEIGHT_MAP.keySet()) {
                Integer weight = ClentTest.WEIGHT_MAP.get(ip);

                weightMap.put(ip,new Weight(ip,weight,0));
            }
        }

        //1.currentWeight += weight
        for (Weight weight : weightMap.values()) {
            weight.setCurrentWeight(weight.getCurrentWeight() + weight.getWeight());
        }

        //2.max(currentWeight)
        Weight maxCurrentWeight = null;
        for (Weight weight : weightMap.values()) {
            if (maxCurrentWeight == null || weight.getCurrentWeight() >
                    maxCurrentWeight.getCurrentWeight()) {
                maxCurrentWeight = weight;
            }
        }

        int totalWeight = ClentTest.WEIGHT_MAP.values().stream().mapToInt(weight -> weight).sum();
        //4.max(currentWeight) -= sum(weight);
        maxCurrentWeight.setCurrentWeight(maxCurrentWeight.getCurrentWeight() - totalWeight);

        //5.return
        return maxCurrentWeight.getIp();

3.3一致哈希算法

问题:服务器集群中,用户访问分配给第一台服务器有用户的session,但是再次请求中分配给第二台没有的session,重新登陆的不同步问题?
解决:redis ,tomact ,一致hash算法

一致哈希算法:要保证同一个用户接下来的请求的负载均衡通过客户端的ip,或请求路径与请求参数产生hash值指向同一个服务器.

因为客户端发起的请求情况是无穷尽的(客户但地址不同,请求参数不同),所以对于的hash值也是无穷大的,所以我们不可能把所有的hash值都进行映射到服务器端ip上,所以这里需要用到hash环.

array负载均衡密码_权重_02

每一个IP对应的hashCode是存在环上的 ,同时呈现出来顺时针的走势,如果hash值在ip1到ip2之间则如图指向的是ip2作为结果.

问题:但是如果ip4挂掉了,那么请求将放到ip1上面,因为是顺时针.产生了不公平?
解决:需要加入虚拟节点,如:(是将请求平均分配了下)

array负载均衡密码_负载均衡_03

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

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

array负载均衡密码_array负载均衡密码_04

这个彩虹环也是"公平的",并且只有ip 1,2,3,4使实际的服务器ip,其他的都是虚拟IP;

步骤:

1.> hashCode,虚拟节点

2.采用treemap实现有序

private static TreeMap<Integer,String> treeMap = new TreeMap<>();
    private static final int VIRTUAL_NODES = 160; //虚拟节点

    static {
        for (String ip : ClentTest.LIST) {
            for (int i = 0; i < VIRTUAL_NODES; i++) {
                int hash = getHash(ip + i);
                treeMap.put(hash,ip);
            }
        }
    }

    public static String getServer(String client) {
        int hash = getHash(client);
        //找大于hash,treeMap的子树的第一个firstKey
        SortedMap<Integer, String> subMap = treeMap.tailMap(hash);
        Integer firstKey = null;
        if (subMap == null) {
            firstKey = treeMap.firstKey();
        }else {
            firstKey = subMap.firstKey();
        }

        return treeMap.get(firstKey);

    }

	//计算hash
    private static int getHash(String str) {
        final int p = 16777619;
        int hash = (int)2166136261L;
        for (int i = 0;i < str.length();i++) {
            hash = (hash ^ str.charAt(i) * p);
        }
        hash += hash << 13;
        hash ^= hash >> 7;
        hash += hash << 3;
        hash ^= hash >> 17;
        hash += hash << 5;
        //算出为负数取其绝对值
        if(hash < 0) hash = Math.abs(hash);
        return hash;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 12; i++) {
            System.out.println(getServer("client" + i));
        }
    }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。