负载均衡加权轮询算法是如何计算的？

负载均衡加权轮询算法是一种常见的负载均衡策略，它根据服务器的处理能力分配请求，确保高性能服务器处理更多请求，低性能服务器处理较少请求，以下是关于负载均衡加权轮询算法的详细解释：

基本概念

1、权重（Weight）：每台服务器被分配一个权重值，代表其处理能力，权重越高，表示该服务器能够处理更多的请求。

2、当前权重（Current Weight）：在调度过程中，每台服务器的当前权重会根据其权重动态调整。

3、最大公约数（GCD, Greatest Common Divisor）：所有服务器权重的最大公约数，用于调整当前权重。

算法原理

加权轮询算法的核心思想是根据服务器的权重分配请求，使得高性能服务器承担更多的请求，低性能服务器承担较少的请求，具体步骤如下：

1、计算权重相关参数：首先计算所有服务器权重的最大值（max(S)）和最大公约数（gcd(S)）。

2、初始化变量：设置当前索引（index）为-1，当前权重（current_weight）为最大权重值（max(S)）。

3、请求调度：当有请求到来时，从当前索引+1开始轮询服务器数组，找到权重大于当前权重的第一个服务器，用于处理该请求，记录该服务器的索引到结果序列中。

4、调整当前权重：如果到达数组末尾，则重新从头开始搜索，并且减小当前权重的值：current_weight -= gcd(S)，如果current_weight等于0，则重置为max(S)。

示例

假设有三台服务器，权重分别为a=1, b=2, c=4，Nginx每收到7个客户端的请求，会把其中的1个转发给后端a，把其中的2个转发给后端b，把其中的4个转发给后端c。

代码实现

以下是加权轮询算法的C++实现示例：

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
typedef struct {
    int weight;
    char name[2];
} server;
int getsum(int *set, int size) {
    int i = 0; 
    int res = 0;
    for (i = 0; i < size; i++)
        res += set[i];
    return res;
}
int gcd(int a, int b) {
    int c;
    while(b) {
        c = b;
        b = a % b;
        a = c;
    }
    return a;
}
int getgcd(int *set, int size) {
    int i = 0; 
    int res = set[0];
    for (i = 1; i < size; i++)
        res = gcd(res, set[i]);
    return res;
}
int getmax(int *set, int size) {
    int i = 0; 
    int res = set[0];
    for (i = 1; i < size; i++) {
        if (res < set[i]) res = set[i];
    }
    return res;
}
int lb_wrr__getwrr(server *ss, int size, int gcd, int maxweight, int *i, int *cw) {
    while (1) {
        *i = (*i + 1) % size;
        if (*i == 0) {
            *cw = *cw gcd;
            if (*cw <= 0) {
                *cw = maxweight;
                if (*cw == 0) {
                    return -1;
                }
            }
        }
        if (ss[*i].weight >= *cw) {
            return *i;
        }
    }
}
void wrr(server *ss, int *weights, int size) {
    int i = 0;
    int gcd = getgcd(weights, size);
    int max = getmax(weights, size);
    int sum = getsum(weights, size);
    int index = -1;
    int curweight = 0;
    for (i = 0; i < sum; i++) {
        lb_wrr__getwrr(ss, size, gcd, max, &(index), &(curweight));
        printf("%s(%d) ", ss[index].name, ss[index].weight);
    }
    printf("
");
    return;
}
server *initServers(char **names, int *weights, int size) {
    int i = 0;
    server *ss = calloc(size, sizeof(server));
    for (i = 0; i < size; i++) {
        ss[i].weight = weights[i];
        memcpy(ss[i].name, names[i], 2);
    }
    return ss;
}

小伙伴们，上文介绍了“负载均衡加权轮询怎么算”的内容，你了解清楚吗？希望对你有所帮助，任何问题可以给我留言，让我们下期再见吧。