go实现四大负载均衡策略

已于 2022-11-20 14:57:41 修改
阅读量525 收藏 1
点赞数 1
文章标签： 负载均衡 服务器 运维
于 2022-11-20 14:56:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50887645/article/details/127948858
版权

目录

一、四大负载均衡策略

1.随机负载

2.轮询负载

3.加权负载

4.一致性hash负载

二.具体实现

1.随机负载

2.轮询负载

3.加权负载

4.一致性hash负载

一、四大负载均衡策略

1.随机负载

随机挑选目标服务器IP

2.轮询负载

ABC三台服务器，ABCABC依次轮询

3.加权负载

给目标设置访问权重，按照权重轮询

4.一致性hash负载

请求固定URL访问指定IP

二.具体实现

1.随机负载

    random.go

package load_balance

import (
	"errors"
	"fmt"
	"math/rand"
	"strings"
)

type RandomBalance struct {
	curIndex int
	rss      []string
}

func (r *RandomBalance) Add(params ...string) error {
	if len(params) == 0 {
		return errors.New("param len 1 at least")
	}
	addr := params[0]
	r.rss = append(r.rss, addr)
	return nil
}

func (r *RandomBalance) Next() string {
	if len(r.rss) == 0 {
		return ""
	}
	r.curIndex = rand.Intn(len(r.rss))
	return r.rss[r.curIndex]
}

func (r *RandomBalance) Get(key string) (string, error) {
	return r.Next(), nil
}

func (r *RandomBalance) SetConf(conf LoadBalanceConf) {
	r.conf = conf
}

func (r *RandomBalance) Update() {
	if conf, ok := r.conf.(*LoadBalanceZkConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		r.rss = []string{}
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
	if conf, ok := r.conf.(*LoadBalanceCheckConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		r.rss = nil
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
}

    测试类     random_test.go

package load_balance

import (
	"fmt"
	"testing"
)

func TestRandomBalance(t *testing.T) {
	rb := &RandomBalance{}
	rb.Add("127.0.0.1:2003") //0
	rb.Add("127.0.0.1:2004") //1
	rb.Add("127.0.0.1:2005") //2
	rb.Add("127.0.0.1:2006") //3
	rb.Add("127.0.0.1:2007") //4

	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
}

2.轮询负载

    round_robin.go

package load_balance

import (
	"errors"
	"fmt"
	"strings"
)

type RoundRobinBalance struct {
	curIndex int
	rss      []string
}

func (r *RoundRobinBalance) Add(params ...string) error {
	if len(params) == 0 {
		return errors.New("param len 1 at least")
	}
	addr := params[0]
	r.rss = append(r.rss, addr)
	return nil
}

func (r *RoundRobinBalance) Next() string {
	if len(r.rss) == 0 {
		return ""
	}
	lens := len(r.rss) //5
	if r.curIndex >= lens {
		r.curIndex = 0
	}
	curAddr := r.rss[r.curIndex]
	r.curIndex = (r.curIndex + 1) % lens
	return curAddr
}

func (r *RoundRobinBalance) Get(key string) (string, error) {
	return r.Next(), nil
}

func (r *RoundRobinBalance) SetConf(conf LoadBalanceConf) {
	r.conf = conf
}

func (r *RoundRobinBalance) Update() {
	if conf, ok := r.conf.(*LoadBalanceZkConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		r.rss = []string{}
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
	if conf, ok := r.conf.(*LoadBalanceCheckConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		r.rss = nil
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
}

    测试类     round_robin_test.go 

package load_balance

import (
	"fmt"
	"testing"
)

func Test_main(t *testing.T) {
	rb := &RoundRobinBalance{}
	rb.Add("127.0.0.1:2003") //0
	rb.Add("127.0.0.1:2004") //1
	rb.Add("127.0.0.1:2005") //2
	rb.Add("127.0.0.1:2006") //3
	rb.Add("127.0.0.1:2007") //4

	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
}

3.加权负载

    weight_round_robin.go 

package load_balance

import (
	"errors"
	"fmt"
	"strconv"
	"strings"
)

type WeightRoundRobinBalance struct {
	curIndex int
	rss      []*WeightNode
	rsw      []int
}

type WeightNode struct {
	addr            string
	weight          int //权重值
	currentWeight   int //节点当前权重
	effectiveWeight int //有效权重
}

func (r *WeightRoundRobinBalance) Add(params ...string) error {
	if len(params) != 2 {
		return errors.New("param len need 2")
	}
	parInt, err := strconv.ParseInt(params[1], 10, 64)
	if err != nil {
		return err
	}
	node := &WeightNode{addr: params[0], weight: int(parInt)}
	node.effectiveWeight = node.weight
	r.rss = append(r.rss, node)
	return nil
}

func (r *WeightRoundRobinBalance) Next() string {
	total := 0
	var best *WeightNode
	for i := 0; i < len(r.rss); i++ {
		w := r.rss[i]
		//step 1 统计所有有效权重之和
		total += w.effectiveWeight

		//step 2 变更节点临时权重为的节点临时权重+节点有效权重
		w.currentWeight += w.effectiveWeight

		//step 3 有效权重默认与权重相同，通讯异常时-1, 通讯成功+1，直到恢复到weight大小
		if w.effectiveWeight < w.weight {
			w.effectiveWeight++
		}
		//step 4 选择最大临时权重点节点
		if best == nil || w.currentWeight > best.currentWeight {
			best = w
		}
	}
	if best == nil {
		return ""
	}
	//step 5 变更临时权重为 临时权重-有效权重之和
	best.currentWeight -= total
	return best.addr
}

func (r *WeightRoundRobinBalance) Get(key string) (string, error) {
	return r.Next(), nil
}

func (r *WeightRoundRobinBalance) SetConf(conf LoadBalanceConf) {
	r.conf = conf
}

func (r *WeightRoundRobinBalance) Update() {
	if conf, ok := r.conf.(*LoadBalanceZkConf); ok {
		fmt.Println("WeightRoundRobinBalance get conf:", conf.GetConf())
		r.rss = nil
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
	if conf, ok := r.conf.(*LoadBalanceCheckConf); ok {
		fmt.Println("WeightRoundRobinBalance get conf:", conf.GetConf())
		r.rss = nil
		for _, ip := range conf.GetConf() {
			r.Add(strings.Split(ip, ",")...)
		}
	}
}

    测试类     weight_round_robin_test.go 

package load_balance

import (
	"fmt"
	"testing"
)

func TestLB(t *testing.T) {
	rb := &WeightRoundRobinBalance{}
	rb.Add("127.0.0.1:2003", "4") //0
	rb.Add("127.0.0.1:2004", "3") //1
	rb.Add("127.0.0.1:2005", "2") //2

	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
	fmt.Println(rb.Next())
}

4.一致性hash负载

    consistent_hash.go 

package load_balance

import (
	"errors"
	"fmt"
	"hash/crc32"
	"sort"
	"strconv"
	"strings"
	"sync"
)

type Hash func(data []byte) uint32

type UInt32Slice []uint32

func (s UInt32Slice) Len() int {
	return len(s)
}

func (s UInt32Slice) Less(i, j int) bool {
	return s[i] < s[j]
}

func (s UInt32Slice) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}

type ConsistentHashBanlance struct {
	mux      sync.RWMutex
	hash     Hash
	replicas int               //复制因子
	keys     UInt32Slice       //已排序的节点hash切片
	hashMap  map[uint32]string //节点哈希和Key的map,键是hash值，值是节点key
}

func NewConsistentHashBanlance(replicas int, fn Hash) *ConsistentHashBanlance {
	m := &ConsistentHashBanlance{
		replicas: replicas,
		hash:     fn,
		hashMap:  make(map[uint32]string),
	}
	if m.hash == nil {
		//最多32位,保证是一个2^32-1环
		m.hash = crc32.ChecksumIEEE
	}
	return m
}

// 验证是否为空
func (c *ConsistentHashBanlance) IsEmpty() bool {
	return len(c.keys) == 0
}

// Add 方法用来添加缓存节点，参数为节点key，比如使用IP
func (c *ConsistentHashBanlance) Add(params ...string) error {
	if len(params) == 0 {
		return errors.New("param len 1 at least")
	}
	addr := params[0]
	c.mux.Lock()
	defer c.mux.Unlock()
	// 结合复制因子计算所有虚拟节点的hash值，并存入m.keys中，同时在m.hashMap中保存哈希值和key的映射
	for i := 0; i < c.replicas; i++ {
		hash := c.hash([]byte(strconv.Itoa(i) + addr))
		c.keys = append(c.keys, hash)
		c.hashMap[hash] = addr
	}
	// 对所有虚拟节点的哈希值进行排序，方便之后进行二分查找
	sort.Sort(c.keys)
	return nil
}

// Get 方法根据给定的对象获取最靠近它的那个节点
func (c *ConsistentHashBanlance) Get(key string) (string, error) {
	if c.IsEmpty() {
		return "", errors.New("node is empty")
	}
	hash := c.hash([]byte(key))

	// 通过二分查找获取最优节点，第一个"服务器hash"值大于"数据hash"值的就是最优"服务器节点"
	idx := sort.Search(len(c.keys), func(i int) bool { return c.keys[i] >= hash })

	// 如果查找结果 大于 服务器节点哈希数组的最大索引，表示此时该对象哈希值位于最后一个节点之后，那么放入第一个节点中
	if idx == len(c.keys) {
		idx = 0
	}
	c.mux.RLock()
	defer c.mux.RUnlock()
	return c.hashMap[c.keys[idx]], nil
}

func (c *ConsistentHashBanlance) SetConf(conf LoadBalanceConf) {
	c.conf = conf
}

func (c *ConsistentHashBanlance) Update() {
	if conf, ok := c.conf.(*LoadBalanceZkConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		c.keys = nil
		c.hashMap = nil
		for _, ip := range conf.GetConf() {
			c.Add(strings.Split(ip, ",")...)
		}
	}
	if conf, ok := c.conf.(*LoadBalanceCheckConf); ok {
		fmt.Println("Update get conf:", conf.GetConf())
		c.keys = nil
		c.hashMap = map[uint32]string{}
		for _, ip := range conf.GetConf() {
			c.Add(strings.Split(ip, ",")...)
		}
	}
}

    测试类     consistent_hash_test.go 

package load_balance

import (
	"fmt"
	"testing"
)

func TestNewConsistentHashBanlance(t *testing.T) {
	rb := NewConsistentHashBanlance(10, nil)
	rb.Add("127.0.0.1:2003") //0
	rb.Add("127.0.0.1:2004") //1
	rb.Add("127.0.0.1:2005") //2
	rb.Add("127.0.0.1:2006") //3
	rb.Add("127.0.0.1:2007") //4

	//url hash
	fmt.Println(rb.Get("http://127.0.0.1:2002/base/getinfo"))
	fmt.Println(rb.Get("http://127.0.0.1:2002/base/error"))
	fmt.Println(rb.Get("http://127.0.0.1:2002/base/getinfo"))
	fmt.Println(rb.Get("http://127.0.0.1:2002/base/changepwd"))

	//ip hash
	fmt.Println(rb.Get("127.0.0.1"))
	fmt.Println(rb.Get("192.168.0.1"))
	fmt.Println(rb.Get("127.0.0.1"))
}

WyWuu
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
golang 微服务的负载均衡
m0_37322399的博客
05-14 1096
上次我们说了一下 微服务的容错处理，是用的 断路器这一次我们来一起看看 微服务的负载均衡是如何做的负载均衡是什么呢？他能够将大量的请求，根据负载均衡算法，将不同的请求分发到多台服务器上进行处理，使得所有的服务器负载都维持在一个高效稳定的状态，进而可以提高系统的吞吐量，和保证系统的可用性例如我们的访问服务器是这样的用户 – 网络 – 服务器 – 数据库那么，如果这一个服务器的请求数很高，超过了服务器能能处理的极限，自身无法及时响应的时候，则会出现异常，甚至无法连接，用户就无法得到及时的期望结果那么我们至少
go简单实现几种常见的负载均衡
qq_46004291的博客
04-15 1474
今天试试用go实现四种常见的负载均衡，分别是随机负载均衡，轮询负载均衡，加权负载均衡，一致性hash负载均衡。 随机负载均衡 功能和名字一样，随机从一堆服务器中选择一个服务器，那么实现也很简单，不做过多说明。使用了rand方法随机取一个服务器。 package main import ( "errors" "fmt" "math/rand" ) type RandomBalance struct { curIndex int res []string } func (r *Rand
http代理基础
shuaihao1的博客
05-03 348
反向代理 下游服务器，真实的服务器实现 package main import ( "fmt" "io" "log" "net/http" "os" "os/signal" "syscall" "time" ) func main() { rs1 := &RealServer{Addr: "127.0.0.1:2003"} rs1.Run() rs2 := &RealServer{Addr: "127.0.0.1:2004"} rs2.Run() //监听关
2024年Go最全Round-Robin负载均衡算法及其实现原理_madt core round robin(3)，一个Golang应届生从上海离职
2401_84911346的博客
05-15 242
假如有2台机器 A和B , A的处理能力是B的2倍,则A的权重为2,B的权重为1.权值高的服务器先收到的连接，* 如果服务器的配置的处理能力都一致的话,平均轮询分配可以直接解决问题,然而有些时候机器的处理能力是不一致的., Sn-1} ，有相应的权重，变量i表示上次选择的服务器，* 权值高的服务器比权值低的服务器处理更多的连接，相同权值的服务器处理相同数目的连接数。* 权值cw初始化为0，i初始化为-1 ，当第一次的时候取权值取最大的那个服务器，
Go语言实现常见的负载均衡算法
m0_52530105的博客
06-16 402
​ 负载均衡建立在现有网络结构之上，它提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽、增加吞吐量、加强网络数据处理能力、提高网络的灵活性和可用性。​ 负载均衡*（Load Balance）*其意思就是分摊到多个操作单元上进行执行，例如Web服务器、FTP服务器、企业关键应用服务器和其它关键任务服务器等，从而共同完成工作任务。负载均衡的常见算法有随机负载均衡加权随机负载均衡轮询负载均衡加权负载均衡加权平滑轮询负载均衡一致性hash负载均衡。
15. Go实现负载均衡算法
YouMing_Li的博客
09-26 182
在实际工作中，为了避免单点故障，一个服务一般都是会部署多个实例的，那么请求来的时候，到底使用哪个服务器处理请求呢？这便涉及到了负载均衡算法了。
史上最细gRPC(Go)入门教程(十二)---客户端负载均衡
探索云原生
05-29 2409
本文主要介绍了 gRPC 内置的负载均衡策略及其配置与使用，包括 Name Resolver、ServiceConfig 等。 gRPC 系列相关代码见 Github 1. 概述 gRPC 负载均衡包括客户端负载均衡和服务端负载均衡两种方向。本文主要介绍的是客户端负载均衡。 gRPC 的客户端负载均衡主要分为两个部...
golang grpc 负载均衡的方法
01-03
微服务架构里面，每个服务都会有很多节点，如果流量分配不均匀，会造成资源的浪费，甚至将一些机器压垮，这个时候就需要负载均衡，最简单的一种策略就是轮询，顺序依次选择不同的节点访问。 grpc 在客户端提供了负载...
Django高并发负载均衡实现原理详解
12-20
Django高并发负载均衡实现原理详解 在面对高并发访问时，单一服务器的性能往往不足以应对，这时就需要采用服务器集群来提升网站的处理能力。负载均衡是解决这一问题的关键技术，其目标是确保所有后端服务器能充分...
Go接口练习之负载均衡算法
01-07
Web请求中，申请服务，为了避免多个服务都集中运行在一个服务器山，于是有了负载均衡，本文撰写了随机算法和轮渡(顺序)算法 balance包 balance.go package balance // 负载均衡接口 type Balance interface{ ...
Golang_Godhcplb是facebook为DHCP实现的负载均衡器.zip
最新发布
05-26
总的来说，"Golang_Godhcplb"是Facebook为了解决大规模网络环境中DHCP服务的负载问题而设计的解决方案，利用Go语言的优势实现了高效、可靠的负载均衡。通过深入研究和使用这个项目，我们可以学习到如何用Go语言构建...
go 进阶 go-zero相关: 六. 负载均衡与请求的发出
qq_29799655的博客
05-11 478
在调用p2cPicker的pick()方法中首先会将节点封装为SubConn, 会执行p2cPicker下的choose()选择指定节点,在choose()方法内部会调用subConn的load()方法计算节点的负载情况,选择最低的一个,查看该方法 参考博客
[golang 微服务] 8.go-micro的负载均衡操作，go Web框(Gin,Beego)调用go-micro微服务
zhoupenghui168的博客
06-30 1507
go-micro的负载均衡操作，go Web框(Gin,Beego)调用go-micro微服务以及Gin,Beego创建微服务客户端操作，以及Gin, Beego框架调用微服务go-micro案例
GO+Nginx实现服务器的高并发+负载均衡（超级简单，开箱即用）
qq_41866988的博客
08-04 1078
Go部分的代码，我没怎么详细讲，大概意思大家应该能看懂，里面我还使用了令牌桶来对请求当前api的连接数做了限制，可以在Nginx的ip限制下再做一次限制，可以简单达到下面的两个功能保护服务器资源：通过限制请求数，可以防止服务器过载。当同时接收到大量的请求时，服务器的资源（如 CPU、内存和网络带宽）可能会耗尽，导致性能下降甚至崩溃。通过限制请求数，可以确保服务器能够合理地处理请求，避免资源耗尽。提高系统稳定性：通过限制请求数，可以防止某些恶意用户或恶意程序通过发送大量请求来攻击服务器。
go语言实现负载均衡算法
weixin_46529397的博客
06-10 91
基于轮询和随机的负载均衡算法实现方式。
Golang 简单的读负载均衡
王清培的个人博客
02-23 460
read-loadbalance master-slave(n) 读库集群负载均衡器(简单轮询)+时间间隔错峰。 github 地址：https://github.com/Plen-wang/read-loadbalance 使用场景 1.一般我们会有多个从库，需要在从库的读取上做负载均衡。 2.在数仓拉取数据的时候经常对产线DB造成影响，所以会独立一个从库专门用来拉取，但是这个从库的利用率非常...
go 进阶 go-zero相关: 三. go-zero 微服务基础示例
qq_29799655的博客
05-10 1504
编译命令执行完毕后,会生成一下代码:其中 types/XXX/xxx.pb.go文件与types/XXX/xxx_grpc.pb.go是通过proto生成的,参考grpc“xxx.pb.go”: 内部是编写这个rpc服务时自定义的结构体相关处理“xxx_grpc.pb.go”: 内部是启动这个rpc服务端,启动访问这个rpc客户端的相关代码通过go-zero生成的其中user.proto是用来生成rpc服务的IDL文件。
负载均衡原理及Golang实现
u010451334的博客
06-30 417
负载均衡能够将客户端流量平均分配到服务器阵列，解决大量并发访问服务问题，是分布式场景下服务治理的重要手段
go-zero负载均衡算法源码阅读
王安的博客
05-09 480
负载均衡，p2c负载均衡算法gozero实现
golang select 实现负载均衡
05-18
在 Go 中，可以使用 select 语句实现负载均衡。具体地，可以将请求分发给多个处理器进行处理，以实现负载均衡的效果。以下是一个简单的示例代码： ```go func main() { numWorkers := 3 jobs := make(chan int, 5) results := make(chan int, 5) for i := 0; i < numWorkers; i++ { go worker(i, jobs, results) } for i := 0; i < 5; i++ { jobs <- i } close(jobs) for i := 0; i < 5; i++ { fmt.Println(<-results) } } func worker(id int, jobs <-chan int, results chan<- int) { for j := range jobs { fmt.Println("worker", id, "processing job", j) time.Sleep(time.Second) results <- j * 2 } } ``` 在上述代码中，我们首先创建了三个处理器（即 worker），并将它们分别放入 goroutine 中运行。然后，我们创建了两个通道，jobs 用于传递任务，results 用于传递任务处理结果。接下来，我们往 jobs 通道中发送了 5 个任务，然后关闭了 jobs 通道，以便告诉 worker 程序已经发送完毕。最后，我们从 results 通道中读取处理结果并打印出来。 在 worker 函数中，我们使用 range 关键字迭代 jobs 通道中的任务。每当有新的任务到来时，worker 就会输出该任务的编号，并将处理结果发送到 results 通道中。由于使用了 time.Sleep(time.Second) 语句，因此每个任务的处理时间为 1 秒钟。 在主函数中，我们使用 select 语句来实现负载均衡。具体地，select 会等待 jobs 和 results 通道中的数据，并分别将它们分发给空闲的 worker 进行处理。当某个 worker 完成一个任务时，会将处理结果发送到 results 通道中，然后再次进入 select 语句等待新的任务。 总之，通过使用 select 语句实现负载均衡，可以使得多个处理器能够协同处理任务，提高系统的并发处理能力和性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值