答案： 通过通道可以实现并发限流和负载均衡。并发限流：使用通道阻止 goroutine 直到有可用的通道，防止过多 goroutine 同时访问资源。使用 sync.waitgroup 跟踪访问资源的 goroutine 数量，并相应地向通道发送信号。负载均衡：使用通道将任务分配给多个工作程序。工作程序独立从通道获取任务并处理，确保任务均匀分布。
Go 函数：使用通道实现并发限流和负载均衡
并发限流
使用通道可以轻松实现并发限流。当一个goroutine试图访问受限的资源时，它会被阻塞，直到有可用的通道。这样可以防止同时有太多 goroutine 同时访问资源。我们可以使用 sync.WaitGroup 来跟踪有多少 goroutine 正在访问资源，并相应地向通道发送信号。
立即学习“go语言免费学习笔记（深入）”；
import (
"sync"
"time"
)
// Limiter is a concurrency limiter.
type Limiter struct {
mu sync.Mutex
limit int
queue chan struct{}
}
// NewLimiter creates a new concurrency limiter.
func NewLimiter(limit int) *Limiter {
return &Limiter{
limit: limit,
queue: make(chan struct{}, limit),
}
}
// Wait waits for a slot in the limiter.
func (l *Limiter) Wait() {
l.mu.Lock()
l.queue <- struct{}{}
l.mu.Unlock()
}
// Release releases a slot in the limiter.
func (l *Limiter) Release() {
l.mu.Lock()
<-l.queue
l.mu.Unlock()
}负载均衡
另一个有用的通道使用方法是负载均衡。我们可以使用通道将任务分布到多个工作程序。工作程序从通道获取任务，并独立处理它们。此方法可确保任务均匀分布在所有工作程序上。
import (
"sync"
"time"
)
// LoadBalancer is a load balancer.
type LoadBalancer struct {
mu sync.Mutex
tasks chan interface{}
workers []*Worker
numWorkers int
}
// NewLoadBalancer creates a new load balancer.
func NewLoadBalancer(numWorkers int) *LoadBalancer {
return &LoadBalancer{
tasks: make(chan interface{}),
workers: make([]*Worker, numWorkers),
numWorkers: numWorkers,
}
}
// AddWorker adds a worker to the load balancer.
func (l *LoadBalancer) AddWorker(w *Worker) {
l.mu.Lock()
l.workers = append(l.workers, w)
l.mu.Unlock()
}
// SubmitTask submits a task to the load balancer.
func (l *LoadBalancer) SubmitTask(task interface{}) {
l.tasks <- task
}
// Start starts the load balancer.
func (l *LoadBalancer) Start() {
for i := 0; i < l.numWorkers; i++ {
w := NewWorker(l.tasks)
l.AddWorker(w)
go w.Start()
}
}
// Worker is a worker that processes tasks from a load balancer.
type Worker struct {
tasks chan interface{}
}
// NewWorker creates a new worker.
func NewWorker(tasks chan interface{}) *Worker {
return &Worker{tasks: tasks}
}
// Start starts the worker.
func (w *Worker) Start() {
for task := range w.tasks {
// Process the task.
_ = task
}
}实战案例
并发限流
假设我们有一个只处理 10 个请求的资源。我们可以使用上面的 Limiter 来限制对该资源的并发访问：
import (
"fmt"
"sync"
)
func main() {
var wg sync.WaitGroup
l := NewLimiter(10)
for i := 0; i < 100; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
l.Wait()
// Access the shared resource.
fmt.Printf("Goroutine %d is accessing the shared resource.\n", i)
time.Sleep(100 * time.Millisecond)
l.Release()
}(i)
}
wg.Wait()
}负载均衡
假设我们有一个将整数加 1 的任务列表。我们可以使用 LoadBalance 使任务分布在多个工作程序上：
import (
"fmt"
"sync"
)
func main() {
lb := NewLoadBalancer(4)
for i := 0; i < 100; i++ {
lb.SubmitTask(i)
}
lb.Start()
// Wait for all tasks to finish.
var wg sync.WaitGroup
wg.Add(100)
go func() {
for v := range lb.tasks {
wg.Done()
fmt.Printf("Processed task: %d\n", v)
}
}()
wg.Wait()
} 
