golang框架在高并发场景中如何防止资源耗尽

import (
    "sync"
    "sync/atomic"
    "time"
)

var (
    maxRequestSize int32
    requestQueue   = make(chan int, maxRequestSize)
    wg             sync.WaitGroup
)

func handleRequest() {
    defer wg.Done()

    <-requestQueue

    // 处理请求
}

func main() {
    maxRequestSize = 1000

    for i := 0; i < maxRequestSize; i++ {
        wg.Add(1)
        go handleRequest()
    }

    for {
        requestQueue <- 1
    }
}

import (
    "sync"
    "time"
)

var (
    maxWorkerCount int
    wg             sync.WaitGroup
)

func doWork() {
    defer wg.Done()

    // 处理任务
}

func main() {
    maxWorkerCount = 10

    for {
        wg.Add(1)
        go doWork()

        wg.Wait()

        time.Sleep(1 * time.Second)
    }
}

import (
    "runtime"
    "time"
)

func main() {
    for {
        // 获取当前内存使用情况
        memStats := new(runtime.MemStats)
        runtime.ReadMemStats(memStats)

        // 打印内存使用信息
        fmt.Printf("Alloc: %d KiB, TotalAlloc: %d KiB, Sys: %d KiB, NumGC: %d\n",
            memStats.Alloc/1024, memStats.TotalAlloc/1024, memStats.Sys/1024, memStats.NumGC)

        time.Sleep(1 * time.Second)
    }
}

import (
    "fmt"
    "net/http"
    "sync"
    "sync/atomic"
    "time"
)

var (
    maxRequestSize    int32
    requestQueue      = make(chan int, maxRequestSize)
    workerCount       int
    activeWorkerCount int32
    wg                sync.WaitGroup
)

func handleRequest() {
    defer wg.Done()
    atomic.AddInt32(&activeWorkerCount, -1)

    <-requestQueue

    // 处理请求
}

func worker() {
    for {
        res := tryAcquireWork()
        if !res {
            return
        }

        handleRequest()
    }
}

func tryAcquireWork() bool {
    if activeWorkerCount >= maxWorkerCount {
        return false
    }

    atomic.AddInt32(&activeWorkerCount, 1)
    return true
}

func main() {
    maxRequestSize = 1000
    workerCount = 10
    activeWorkerCount = 0

    for i := 0; i < workerCount; i++ {
        wg.Add(1)
        go worker()
    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        requestQueue <- 1
    })

    http.ListenAndServe(":8080", nil)
}