负载均衡之加权轮询算法

作者：gqtcgq

在介绍加权轮询算法(WeightedRound-Robin)之前，首先介绍一下轮询算法(Round-Robin)。

　　轮询算法是最简单的一种负载均衡算法。它的原理是把来自用户的请求轮流分配给内部的服务器：从服务器1开始，直到服务器N，然后重新开始循环。

　　算法的优点是其简洁性，它无需记录当前所有连接的状态，所以它是一种无状态调度。

　　假设有N台服务器：S = {S1, S2, …, Sn}，一个指示变量i表示上一次选择的服务器ID。变量i被初始化为N-1。该算法的伪代码如下：

j = i;
do
{
j = (j + 1) mod n;
i = j;
return Si;
} while (j != i);
return NULL;

　　轮询算法假设所有服务器的处理性能都相同，不关心每台服务器的当前连接数和响应速度。当请求服务间隔时间变化比较大时，轮询算法容易导致服务器间的负载不平衡。所以此种均衡算法适合于服务器组中的所有服务器都有相同的软硬件配置并且平均服务请求相对均衡的情况。

二：加权轮询算法(WeightedRound-Robin)

　　轮询算法并没有考虑每台服务器的处理能力，实际中可能并不是这种情况。由于每台服务器的配置、安装的业务应用等不同，其处理能力会不一样。所以，加权轮询算法的原理就是：根据服务器的不同处理能力，给每个服务器分配不同的权值，使其能够接受相应权值数的服务请求。

　　首先看一个简单的Nginx负载均衡配置。

http { 
upstream cluster { 
server a weight=1; 
server b weight=2; 
server c weight=4; 
} 
...
}

　　按照上述配置，Nginx每收到7个客户端的请求，会把其中的1个转发给后端a，把其中的2个转发给后端b，把其中的4个转发给后端c。

　　加权轮询算法的结果，就是要生成一个服务器序列。每当有请求到来时，就依次从该序列中取出下一个服务器用于处理该请求。比如针对上面的例子，加权轮询算法会生成序列{c, c, b, c, a, b, c}。这样，每收到7个客户端的请求，会把其中的1个转发给后端a，把其中的2个转发给后端b，把其中的4个转发给后端c。收到的第8个请求，重新从该序列的头部开始轮询。

　　总之，加权轮询算法要生成一个服务器序列，该序列中包含n个服务器。n是所有服务器的权重之和。在该序列中，每个服务器的出现的次数，等于其权重值。并且，生成的序列中，服务器的分布应该尽可能的均匀。比如序列{a, a, a, a, a, b, c}中，前五个请求都会分配给服务器a，这就是一种不均匀的分配方法，更好的序列应该是：{a, a, b, a, c, a, a}。

　　下面介绍两种加权轮询算法：

1：普通加权轮询算法

这种算法的原理是：在服务器数组S中，首先计算所有服务器权重的最大值max(S)，以及所有服务器权重的最大公约数gcd(S)。

index表示本次请求到来时，选择的服务器的索引，初始值为-1；current_weight表示当前调度的权值，初始值为max(S)。

当请求到来时，从index+1开始轮询服务器数组S，找到其中权重大于current_weight的第一个服务器，用于处理该请求。记录其索引到结果序列中。

　　在轮询服务器数组时，如果到达了数组末尾，则重新从头开始搜索，并且减小current_weight的值：current_weight -= gcd(S)。如果current_weight等于0，则将其重置为max(S)。

　　该算法的实现代码如下：

#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("\n");
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;
}

int main()
{
int i = 0;

int weights[] = {1, 2, 4};
char *names[] = {"a", "b", "c"};
int size = sizeof(weights) / sizeof(int);


server *ss = initServers(names, weights, size);

printf("server is ");
for (i = 0; i < size; i++)
{
printf("%s(%d) ", ss[i].name, ss[i].weight);
}
printf("\n");

printf("\nwrr sequence is ");
wrr(ss, weights, size);

return;
}

View Code