Golang 函数：使用通道实现并发限流和负载均衡

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
    }
}

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()
}

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()
}