1 加权轮询的实例

加权轮询负载均衡算法
加权轮询算法也是一种静态负载均衡方法，它与轮询技术非常相似。唯一的区别是，列表中的每个资源都提供了一个加权分数。根据加权分数，请求将分发到这些服务器。

权重较高的服务器将获得更大比例的请求。
分布是循环的，类似于循环技术，但每个服务器接收的请求数与其权重成正比。
如果服务器达到其处理能力，它可能会开始拒绝或排队其他请求，具体取决于服务器的特定行为。

例如：
假设您的朋友对苹果的渴望程度不同。为了公平，所以你把更多的苹果送给最爱他们的朋友。
加权轮询做类似的事情 – 它给可以更好地处理任务的朋友更多任务。

假设您有三台具有权重的服务器：

Server1（权重 0.3）、Server2（权重 0.2）和 Server3（权重 0.1）。
总权重为 0.3 + 0.2 + 0.1 = 0.6。
在每个周期中，Server1 将收到 0.3/0.6 （50%） 的请求，
Server2 将收到 0.2/0.6 （33.33%），
Server3 将收到 0.1/0.6 （16.67%）。

2 使用go实现的实例

Go实现的带权重的轮询负载均衡器，功能与Java代码相同。此实现中，我们使用结构体来定义服务器（带有名称和权重）以及加权轮询负载均衡器本

package main

import (
	"fmt"
	"math/rand"
	"time"
)

// Server 结构体，包含服务器名称和权重
type Server struct {
	name   string
	weight int
}

// WeightedRoundRobinBalancer 结构体
type WeightedRoundRobinBalancer struct {
	servers          []Server
	cumulativeWeights []int
	totalWeight      int
	random           *rand.Rand
}

// NewWeightedRoundRobinBalancer 构造函数，初始化负载均衡器
func NewWeightedRoundRobinBalancer(servers []Server) *WeightedRoundRobinBalancer {
	balancer := &WeightedRoundRobinBalancer{
		servers: servers,
		random:  rand.New(rand.NewSource(time.Now().UnixNano())),
	}
	balancer.totalWeight = balancer.calculateTotalWeight()
	balancer.cumulativeWeights = balancer.calculateCumulativeWeights()
	return balancer
}

// 计算服务器的总权重
func (w *WeightedRoundRobinBalancer) calculateTotalWeight() int {
	totalWeight := 0
	for _, server := range w.servers {
		totalWeight += server.weight
	}
	return totalWeight
}

// 计算累计权重数组
func (w *WeightedRoundRobinBalancer) calculateCumulativeWeights() []int {
	cumulativeWeights := make([]int, len(w.servers))
	cumulativeWeights[0] = w.servers[0].weight
	for i := 1; i < len(w.servers); i++ {
		cumulativeWeights[i] = cumulativeWeights[i-1] + w.servers[i].weight
	}
	return cumulativeWeights
}

// 获取下一个服务器，使用随机值来确定
func (w *WeightedRoundRobinBalancer) GetNextServer() Server {
	randomValue := w.random.Intn(w.totalWeight)
	for i, cumulativeWeight := range w.cumulativeWeights {
		if randomValue < cumulativeWeight {
			return w.servers[i]
		}
	}
	return w.servers[len(w.servers)-1]
}

func main() {
	// 定义带权重的服务器列表
	serverList := []Server{
		{"Server1", 3},
		{"Server2", 2},
		{"Server3", 1},
	}

	// 创建加权轮询负载均衡器
	balancer := NewWeightedRoundRobinBalancer(serverList)

	// 模拟请求
	for i := 0; i < 10; i++ {
		nextServer := balancer.GetNextServer()
		fmt.Printf("Request %d: Routed to %s\n", i+1, nextServer.name)
	}
}

运行

  Request 1: Routed to Server1
  Request 2: Routed to Server2
  Request 3: Routed to Server1
  Request 4: Routed to Server3
  Request 5: Routed to Server1
  Request 6: Routed to Server2
  Request 7: Routed to Server1
  Request 8: Routed to Server3
  Request 9: Routed to Server2
  Request 10: Routed to Server1

每次运行输出可能不同，因为在带权重的选择中使用了随机数，但服务器将根据其权重的比例更频繁地被选中。

3 实现功能的解释

Server 结构体定义服务器信息，包括名称和权重。
WeightedRoundRobinBalancer 结构体定义带权重的负载均衡器，它包括服务器列表、累计权重数组、总权重和随机生成器。
NewWeightedRoundRobinBalancer 是构造函数，用于计算总权重和累计权重数组。
calculateTotalWeight 计算服务器列表的总权重。
calculateCumulativeWeights 生成累计权重数组，这样便于随机选择权重范围内的服务器。
GetNextServer 方法使用一个随机值在累计权重数组中定位到下一个服务器。
main 函数创建了服务器列表和负载均衡器，并模拟请求，显示请求被路由到的服务器。

4 场景小结

• 何时使用加权轮询负载均衡算法？

当服务器具有不同的容量或性能级别时。
非常适合服务器资源（CPU、内存等）不同的环境。
当您希望最大限度地提高所有服务器的资源利用率时，这非常有用。
有助于防止小型服务器过载，同时有效使用大型服务器。

• 加权轮询负载均衡算法的优缺点

好处：
容量注意事项：通过分配权重来考虑不同的服务器容量。
灵活性：可以调整以有效处理不同的工作负载。

缺点：
复杂性：比简单的循环更复杂。
维护：需要根据服务器容量的变化调整权重。