常用的负载均衡算法

已于 2024-01-08 14:26:40 修改
阅读量1.2k 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 负载均衡
于 2023-01-23 23:52:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dawnto/article/details/128754546
版权

轮询

var num = uint(0)

var serverList = []string{
	"192.168.1.1",
	"192.168.1.2",
	"192.168.1.3",
	"192.168.1.4",
	"192.168.1.5",
}
	
func f0() string {
	defer func() {
		num++
	}()
	return serverList[num%uint(len(serverList))]
}

加权轮询

var num = uint(0)

type server struct {
	addr   string
	weight int
}

var serverList = []server{
	{"192.168.1.2", 1},
	{"192.168.1.1", 2},
	{"192.168.1.3", 2},
	{"192.168.1.4", 3},
	{"192.168.1.5", 2},
}

func f1() string {
	var newServerList []server
	for i := 0; i < len(serverList); i++ {
		for j := 0; j < serverList[i].weight; j++ {
			newServerList = append(newServerList, serverList[i])
		}
	}

	defer func() {
		num++
	}()

	return newServerList[num%uint(len(newServerList))].addr
}

var num = uint(0)

type server struct {
	addr   string
	weight int
}

var serverList = []server{
	{"192.168.1.1", 2},
	{"192.168.1.3", 3},
	{"192.168.1.4", 5},
}

func f2() string { // 节省内存开销	
	sort.Slice(serverList, func(i, j int) bool {
		return serverList[i].weight < serverList[j].weight
	})
	
	totalWeight := func() int {
		sum := 0
		for _, w := range serverList {
			sum += w.weight
		}
		return sum
	}()

	defer func() {
		num++
	}()

	cur := num % uint(totalWeight)
	for _, svr := range serverList {
		if cur < uint(svr.weight) {
			return svr.addr
		}
		cur -= uint(svr.weight)
	}
	return serverList[cur].addr
}

平滑的加权轮询

将访问分散开，避免聚集到同一个服务器。
服务列表: server [“A”,“B”,“C”]
固定权重: weight [2,3,5]
动态权重: currentWeight [0,0,0]

numbercurrentWeight += weightmax(currentWeight)resultmax(currentWeight) -= sum(weight)
12, 3, 55C2, 3, -5
24, 6, 06B4, -4, 0
36, -1, 56A-4, -1, 5
4-2, 2, 1010C-2, 2, 0
50, 5, 55B0, -5, 5
62, -2, 108C2, -2, 0
74, 1, 55C4, 1, -5
86, 4, 06A-4, 4, 0
9-2, 7, 57B-2, -3, 5
100, 0, 1010C0, 0, 0
112, 3, 55C2, 3, -5
12…………
type server struct {
	addr   string
	weight int
}

var serverList = []server{
	{"192.168.1.2", 2},
	{"192.168.1.3", 3},
	{"192.168.1.5", 5},
}

var currentWeightList = func() []int {
	return make([]int, len(serverList))
}()


var sumWeight = func() int {
	sum := 0
	for _, svr := range serverList {
		sum += svr.weight
	}
	return sum
}()

func maxCurrentWeightIndex() (index int) {
	for i := 0; i < len(currentWeightList); i++ {
		if currentWeightList[i] > currentWeightList[index] {
			index = i
		}
	}
	return
}

func f3() string { // 平滑加权轮询
	for i := 0; i < len(serverList); i++ {
		currentWeightList[i] += serverList[i].weight
	}
	idx := maxCurrentWeightIndex()
	currentWeightList[idx] -= sumWeight
	return serverList[idx].addr
}

type server struct {
	addr          string
	weight        int
	currentWeight int
}

type serList []server

func maxServerIndex(list serList) (idx int) {
	idx = 0
	for i := range list {
		if list[i].currentWeight > list[idx].currentWeight {
			idx = i
		}
	}
	return
}

var sumWeight = 0

func loadBalance(list serList) (addr string) {
	for i := 0; i < len(list); i++ {
		list[i].currentWeight += list[i].weight
	}
	index := maxServerIndex(list)
	list[index].currentWeight -= sumWeight
	return list[index].addr
}

func main() {
	var list serList = []server{
		{addr: "A", weight: 2},
		{addr: "B", weight: 3},
		{addr: "C", weight: 5},
	}

	for i := range list {
		sumWeight += list[i].weight
	}

	for i := 0; i < 30; i++ {
		fmt.Print(loadBalance(list))
	}
}

随机

var serverList = []string{
	"192.168.1.1",
	"192.168.1.2",
	"192.168.1.3",
	"192.168.1.4",
	"192.168.1.5",
}

func f4() string {
	rand.Seed(time.Now().UnixNano())
	return serverList[rand.Intn(len(serverList))]
}

加权随机

type server struct {
	addr   string
	weight int
}

var serverList = []server{
	{"192.168.1.2", 2},
	{"192.168.1.3", 3},
	{"192.168.1.5", 5},
}

func f5() string {
	sort.Slice(serverList, func(i, j int) bool {
		return serverList[i].weight < serverList[j].weight
	})
	rand.Seed(time.Now().UnixNano())
	totalWeight := func() int {
		sum := 0
		for _, w := range serverList {
			sum += w.weight
		}
		return sum
	}()
	cur := rand.Intn(totalWeight)

	for _, svr := range serverList {
		if cur < svr.weight {
			return svr.addr
		}
		cur -= svr.weight
	}

	return serverList[cur].addr
}

源地址散列

目标机器不能离线，否则流量回落空

var serverList = []string{
	"192.168.1.1",
	"192.168.1.2",
	"192.168.1.3",
	"192.168.1.4",
	"192.168.1.5",
}

func f6(ip string) string {
	hs := sha256.New()
	hs.Write([]byte(ip))
	value := hs.Sum(nil)
	str := hex.EncodeToString(value)
	index, _ := strconv.ParseUint(str[:16], 16, 64)
	return serverList[uint(index)%uint(len(serverList))]
}

最小连接数

type server struct {
	addr         string
	weight       int
	connectCount int
}

func (s *server) GetConnectCount() int {
	rand.Seed(time.Now().UnixNano())
	s.connectCount = rand.Intn(10000) // 这里用随机数模拟
	return s.connectCount
}

var serverList = []server{
	{"192.168.1.2", 2, 0},
	{"192.168.1.3", 3, 0},
	{"192.168.1.5", 5, 0},
}

func f7() string {
	minIndex := 0
	minCount := math.MaxInt
	for index, svr := range serverList {
		count := svr.GetConnectCount() // 检测每个服务的连接数，取最小值
		if count < minCount {
			minCount = count
			minIndex = index
		}
	}
	return serverList[minIndex].addr
}

子集划分算法

该算法由Google提出。
非本人实现，此处引用文章：https://xie.infoq.cn/article/2075b4d8473854bd606ab49e0

// 请求参数:
//  - backends: 表示当前所有的后端, 例如在上面的演示案例中, 就表示100个Account Service机器
//  - clientID: 客户端唯一ID, 例如在上面的演示案例中, 就表示某一台User Service机器
//  - subsetSize: 子集大小, 也就是要连接多少个后端。在上面的演示案例中, 就表示clientID所代表的某一台User Service机器要连接subsetSize个Account Service
// 
// 返回值: 由subset算法返回的subsetSize个后端列表, 供服务进行连接
func Subset(backends []string, clientID, subsetSize int) []string {
    subsetCount := len(backends) / subsetSize
    // 将客户端划分为多轮, 每一轮计算使用同样的随机排列的列表
    round := clientID / subsetCount
    r := rand.New(rand.NewSource(int64(round)))
    r.Shuffle(len(backends), func(i, j int) { backends[i], backends[j] = backends[j], backends[i] })

    // subsetID代表了目前的客户端
    subsetID := clientID % subsetCount

    start := subsetID * subsetSize
    return backends[start : start+subsetSize]
}

一致性哈希算法

非本人实现，此处引用文章：https://juejin.cn/post/6845166890864607240

package main

import (
	"crypto/sha1"
	"fmt"
	"sort"
	"strconv"
)

//服务器结构体 地址和存储权重
type server struct {
	addr   string
	weight int
}

//当前服务器相关信息
var servers []server

//默认的hash节点数
const defaultNodeNum = 100

//基础虚拟节点
type virtualNode struct {
	nodeKey string
	spotVal uint32
}

type nodes struct {
	virtualNodesArray []virtualNode
}

func (p *nodes) Len() int           { return len(p.virtualNodesArray) }
func (p *nodes) Less(i, j int) bool { return p.virtualNodesArray[i].spotVal < p.virtualNodesArray[j].spotVal }
func (p *nodes) Swap(i, j int)      { p.virtualNodesArray[i], p.virtualNodesArray[j] = p.virtualNodesArray[j], p.virtualNodesArray[i] }
func (p *nodes) Sort()              { sort.Sort(p) }

//生成对应uint32
func getUint32Val(s string) (v uint32) {
	//进行sha1
	h := sha1.New()
	defer h.Reset()
	h.Write([]byte(s))
	hashBytes := h.Sum(nil)
	//go语言的位运算符处理
	if len(hashBytes[4:8]) == 4 {
		v = (uint32(hashBytes[3]) << 24) | (uint32(hashBytes[2]) << 12) | (uint32(hashBytes[1]) << 6) | (uint32(hashBytes[0]) << 3)
	}

	return
}

func (p *nodes) setVirtualNodesArray(servers []server) {
	if len(servers) < 1 {
		return
	}
	//根据权重与节点数，维护一个map - 所有的hash圈上的值对应ip
	for _, v := range servers {
		//第一步计算出每台机器对应的虚拟节点数
		totalVirtualNodeNum := defaultNodeNum * v.weight
		for i := 0; i < totalVirtualNodeNum; i++ {
			iString := strconv.Itoa(i)
			//虚拟节点地址
			virtualAddr := fmt.Sprintf("%s:%s", v.addr, iString)

			virNode := virtualNode{
				nodeKey: v.addr,
				spotVal: getUint32Val(virtualAddr),
			}

			p.virtualNodesArray = append(p.virtualNodesArray, virNode)
		}
		p.Sort()
	}
}

//获取当前数据key对应的存储服务器
func (p *nodes) getNodeSever(w uint32) (addr string){
	i := sort.Search(len(p.virtualNodesArray), func(i int) bool { return p.virtualNodesArray[i].spotVal >= w })
	return p.virtualNodesArray[i].nodeKey
}

func main() {
	vNodes := new(nodes)
	servers = append(servers, server{"127.0.0.1", 1}, server{"127.0.0.2", 2}, server{"127.0.0.3", 3})
	//先赋值，生成虚拟node
	vNodes.setVirtualNodesArray(servers)
	//传入对应的文件名，作为文件key
	fname := "demo.jpg"
	uint32Val := getUint32Val(fname)

	ser := vNodes.getNodeSever(uint32Val)
	fmt.Println("文件对应存储服务器",ser)
}

可以设法优化掉虚拟节点占用的内存。

Reference
https://xie.infoq.cn/article/2075b4d8473854bd606ab49e0
https://juejin.cn/post/6845166890864607240
https://mp.weixin.qq.com/s/-xcrl-u99mZCdfSgUNhYHA

metabit
关注
专栏目录
nginx常用负载均衡算法策略
Bertram的博客
07-27 1845
Nginx是一款轻量级的高性能web服务器，同时也是一款非常优秀的负载均衡器和反向代理服务器。由于支持强大的正则匹配规则、动静分离、URLrewrite功能及安装配置简单且对网络稳定性依赖非常小等优点，所以常用来做为七层负载均衡使用。在硬件不差的情况下，通常可以稳定支持几万的并发连接，在硬件性能足够好，且对系统内核参数及Nginx配置进行优化甚至可以达到10万以上的并发。 以下是Nginx作为七层负载均衡常用的几种调度算法和适用的业务场景 nginx本身支持4种：轮询(round robin), 加权轮.
Robin六种常用负载均衡算法源码解析
m0_46330591的博客
02-28 1178
1 经典轮询算法 在这里插入代码片 //Robin的负载均衡原理为 请求服务=请求次数%服务个数。 //请求计数器 private AtomicInteger nextServerCyclicCounter; public Server choose(ILoadBalancer lb, Object key) { if (lb == null) { log.warn("no load balancer"); return null;
每日一博 - 常用负载均衡算法实现
热门推荐
小工匠
04-30 3万+
文章目录常见的负载均衡算法Dubbo开源实现 常见的负载均衡算法 轮询（Round Robin） 随机（Random） 源地址哈希（Hash） 加权轮询（Weight Round Robin） 加权随机（Weight Random） 最小连接数（Least Connections） 最快响应速度 (Fastest) … Dubbo开源实现 Dubbo： https://dubbo.apache.org/zh/docs/v2.7/dev/source/loadbalance/#21-randomlo
Java 常用负载均衡算法解析
congge
08-22 6291
前言 负载均衡在Java领域中有着广泛深入的应用，不管是大名鼎鼎的nginx，还是微服务治理组件如dubbo，feign等，负载均衡的算法在其中都有着实际的使用 负载均衡的核心思想在于其底层的算法思想，比如大家熟知的算法有 轮询，随机，最小连接，加权轮询等，在现实中不管怎么配置，都离不开其算法的核心原理，下面将结合实际代码对常用的负载均衡算法做一些全面的总结。 轮询算法 轮询即排好队，一个接一个的轮着来。从数据结构上，有一个环状的节点，节点上面布满了服务器，服务器之间首尾相连，带有顺序性。当请求过来的时候，
6种负载均衡算法
小技术君
03-04 2451
当今的分布式系统越来越普遍，由于它们能够提供更高的灵活性和可扩展性。但是，这些系统需要处理大量的客户端请求。为了处理这些请求并提供对每个客户端的稳定和高效的服务，需要使用负载均衡算法。以下是分布式系统中常用的负载均衡算法：????静态算法1.轮询（Round Robin）：将客户端请求按顺序发送到不同的服务实例。服务通常需要是无状态的。2.粘性轮询（Sticky Round Robin）：是轮询算法的改...
13种负载均衡算法
hanhan的博客
10-02 6315
目录（1）轮转调度（Round-Robin Scheduling）算法（2）加权轮转调度（Weighted Round-Robin Scheduling）算法（3）随机均衡调度（Random Scheduling）算法（4）加权随机均衡调度（Weighted Random Scheduling）算法（5）最小连接调度（Least-Connection Scheduling）算法（6）加权最小连接调度（Weighted Least-Connection Scheduling）算法（7）目标地址散列调度（De.
负载均衡常用算法
熊與貓v
08-02 369
负载均衡在大型网站中应用已经是十分普遍了，它在大型网站中处理高并发请求扮演着十分重要的角色。那么负载均衡算法又有哪些呢，一下是一些常见的负载均衡算法： 轮询法（Round Robin） 轮询法基本上算是最简单的负载均衡算法了，它的思想就是不管啥情况，对所有的服务器节点全部按顺序来，将请求按照顺序轮流地分配到各个服务器上。这种算法会使每台服务器处理的请求是相同的，所以适合用于服务器硬件条件基本都相同的场景。 加权轮询法（Weight Robin） 在轮询算法的基础上添加了权重的条件，刚才提到轮询算法对所有
常用负载均衡算法
ZkvIA的博客
10-11 1676
在服务器集群中，为了避免某一台服务器因过载而崩溃，除了每台服务器限定了最大连接数外，还对服务器的负载进行了均分。本文介绍了几个常见的负载均衡算法。 随机 通过随机数生成算法从服务器组中选取一个，然后把请求发送给它。 轮询 所有的服务器组成一个队列，不管连接数、响应时间，从队列首取出一个，然后放到队尾，不断循环。最终把所有的请求平均分给所有的服务器。适用于服务器性能差异不大的
负载均衡中间件及算法解析
weidong22的博客
07-06 821
负载均衡 ● 随机 ● 加权随机 ● 轮询 ● 加权轮询 ● 平滑加权轮询 ● 最小调用时间 ● 一致性hash
常用负载均衡算法概念及实现总结
qq_41512783的博客
07-06 367
常用负载均衡算法概念及实现总结 @author：Jingdai @date：2021.07.06 这篇文章将介绍常用的几个负载均衡算法，随机算法（简单随机、加权随机）、轮询算法（简单轮询、加权轮询、平滑加权轮询）、一致性hash算法。 现代互联网环境下，当流量请求很大的时候，一台服务器就很难很好的完成任务了，就需要用多台服务器建立一个集群来完成任务。 如图，由3个服务器组成的集群，负载均衡算法解决的问题就是如何将流量合理的打到这三台服务器上，使系统的性能达到最佳。 随机算法 简单随机 最简单的办法就是
数据结构与算法笔记——用Go语言描述
Go的全部
11-16 3738
数据结构与算法 用Go语言描述 位运算 位运算——奇淫技巧 位运算——二进制截断和插入 位运算——交换奇偶位 位运算——回文判断 位运算——LeetCode1386. 安排电影院座位 位运算——面试题 17.19. 消失的两个数字 位运算——求1比特数 位运算——476. 数字的补数 位运算——出现一次的数，出现两次的数 查找 二分——有序数组中查找元素 二分——有序数组中，某个数最左或最右的位置 二分——无序无重复元素数组的局部最小值的索引 排序 排序——选择排序 排序——冒泡排序 排序——插入排序 .
go标准库——优先级队列的实现
Go的全部
10-24 3098
package heap_test // priorty_queue是以个带权值观念的queue，它允许加入新元素，移除旧元素，审视元素值等功能 import ( "container/heap" "fmt" "testing" ) // Item 是我们在优先队列中管理的东西 type Item struct { value string // The value of the item; arbitrary. priority int // 队列中项目的优先级 // The
动态规划——编辑距离问题
Go的全部
01-28 2526
动态规划——编辑距离问题
堆定制——1.0强耦合版
Go的全部
10-24 2237
package heap import ( "encoding/json" "fmt" "testing" ) //什么时候需要手写堆，需要更新堆中的某些值，让他自然有序 //迪杰斯特拉算法 就需要这类算法 // 从每个节点扫一遍， 代价会非常高 // 用户：可能对于某一个已经存在的对象，修改值， 在堆上找到，调整到该去的位置，logN级别 type student struct { Name string Age int Height int Weight int
上升子序列的最大长度，递归-记忆化搜索-动态规划三步走
Go的全部
01-27 2188
题目描述： 小明有一个数组，他想从数组任意元素开始向后遍历，找出所有上升子序列，并计算出最长的上升子序列的长度。 上升子序列的最大长度，递归-记忆化搜索-动态规划三步走
search——Bloom Filter
Go的全部
01-19 2185
BitMap
堆排序——Go标准库堆，排序一个几乎有序的数组
Go的全部
10-24 2144
已知一个几乎有序的数组。几乎有序是指，如果把数组排好序的话，每个元素移动的距离一定不超过k,并且k相对于数组的长度来讲是比较小的。 请选择一个合适的排序策略，对这个数组进行排序是最好的。 [x,x,x,x,xx,x] k = 5 排序的话，每一个数字去的位置不超过5 生成一个小根堆 i - i 0 i - i + 1 1 i - i - 1 1 前k + 1 个数进小根堆 堆中0 - 5 的位置会来到0位置 从小根堆中弹出最小值放到0位置，6位置的数不可能来到0位置，因为距离是
常用的负载均衡算法 优缺点
最新发布
03-28
常用的负载均衡算法有以下几种，它们各有优缺点： 1. 轮询算法（Round Robin）：按照顺序依次将请求分发给后端服务器，循环往复。优点是简单、公平，适用于后端服务器性能相近的情况。缺点是无法根据服务器的实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

metabit

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值