负载均衡算法

发表于 | 分类于

轮询算法（round-robin）

1
2
3
4
5
6
7
8
9
10
11
SERVER_LIST = [
    '10.246.10.1',
    '10.246.10.2',
    '10.246.10.3',
]

def round_robin(server_lst, cur = [0]):
    length = len(server_lst)
    ret = server_lst[cur[0] % length]
    cur[0] = (cur[0] + 1) % length
    return ret

加权轮询算法（weight round-robin）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
WEIGHT_SERVER_LIST = {
    '10.246.10.1': 1,
    '10.246.10.2': 3,
    '10.246.10.3': 2,
}

def weight_round_robin(servers, cur = [0]):
    weighted_list = []
    //[ '10.246.10.1',10.246.10.2',10.246.10.2',10.246.10.2','10.246.10.3','10.246.10.3']
    for k, v in servers.iteritems():
        weighted_list.extend([k] * v)

    length = len(weighted_list)
    ret = weighted_list[cur[0] % length]
    cur[0] = (cur[0] + 1) % length
    return ret

随机算法（random）

1
2
3
4
def random_choose(server_lst):
    import random
    random.seed()
    return random.choice(server_lst)

加权随机算法（random）

1
2
3
4
5
6
7
def weight_random_choose(servers):
    import random
    random.seed()
    weighted_list = []
    for k, v in servers.iteritems():
        weighted_list.extend([k] * v)
    return random.choice(weighted_list)

归一化(概率)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def normalize_servers(servers):
    normalized_servers = {}
    total = sum(servers.values())
    cur_sum = 0
    for k, v in servers.iteritems():
        normalized_servers[k] = 1.0 * (cur_sum + v) / total
        cur_sum += v
    return normalized_servers

def weight_random_choose_ex(normalized_servers):
    import random, operator
    random.seed()
    rand = random.random()
    //按照归一化加权值排序
    for k, v in sorted(normalized_servers.iteritems(), key = operator.itemgetter(1)):
        if v >= rand:
            return k
    else:
        assert False, 'Error normalized_servers with rand %s ' % rand

哈希法（hash）

1
2
3
4
//同一个请求能够分配到同样的服务节点，这对于“有状态”的服务很有必要
 def hash_choose(request_info, server_lst):
     hashed_request_info = hash(request_info)
     return server_lst[hashed_request_info % len(server_lst)]

一致性哈希

最少连接算法（least connection）