Golang中如何实现每30个请求的HTTP多线程处理

Golang中如何实现每30个请求的HTTP多线程处理 大家好！我有这段Go代码：

go http.HandleFunc("/", HomePage)
go http.HandleFunc("/king", KingPage)

目前，我只是为每个处理程序创建线程。 但是，我想为每30个用户创建一个线程， 例如：

if requests > 30 {
go http.HandleFunc("/", HomePage)
} else if requests > 60 {
go http.HandleFunc("/", HomePage)
}

但是，我想为30个用户创建一个线程，而目前它会为30个用户创建30个线程。


更多关于Golang中如何实现每30个请求的HTTP多线程处理的实战教程也可以访问 https://www.itying.com/category-94-b0.html

4 回复

Goroutines 不是线程。启动 30 个 goroutines 绝不意味着启动 30 个线程。你可以调度数十万个 goroutines；但使用线程无法做到这一点。

更多关于Golang中如何实现每30个请求的HTTP多线程处理的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Goroutines 是由 Go 运行时管理的轻量级“线程”，不会直接转换为操作系统线程。

除此之外，标准库的 http 包已经自动为每个请求在不同的 goroutine 中处理，无需手动操作。因此，以下代码就足够了：

http.HandleFunc("/", Handler1)
http.HandleFunc("/other", Handler2)

err := http.ListenAndServe(":8080", nil)
...

哦，原来我没有理解 goroutine 的工作原理。 你能给我解释一下它是如何工作的吗？（我阅读了文档，但还是不太明白）。那么 goroutine 会自动创建它需要的所有线程吗？所以我不用添加任何代码，这样写就足够了吗：

go http.HandleFunc("/", HomePage)
go http.HandleFunc("/king", KingPage)

这样我就不需要关心其他任何事情了吗？

在Go语言中，您对HTTP请求处理的理解有误。http.HandleFunc函数用于注册路由处理函数，而不是直接处理每个请求或创建线程。Go的HTTP服务器会自动为每个传入的请求启动一个goroutine（轻量级线程），您无需手动管理线程创建。

如果您想限制并发处理请求的数量，可以使用一个带缓冲的通道作为信号量来控制goroutine的并发数。以下是实现每30个请求限制的示例代码：

package main

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

var requestCount int32

func main() {
    // 创建一个缓冲为30的通道作为信号量
    sem := make(chan struct{}, 30)
    
    // 包装处理函数以限制并发
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // 尝试获取信号量
        sem <- struct{}{}
        defer func() {
            // 释放信号量
            <-sem
        }()
        
        // 原子增加请求计数
        atomic.AddInt32(&requestCount, 1)
        defer atomic.AddInt32(&requestCount, -1)
        
        HomePage(w, r)
    })
    
    http.HandleFunc("/king", func(w http.ResponseWriter, r *http.Request) {
        sem <- struct{}{}
        defer func() {
            <-sem
        }()
        
        atomic.AddInt32(&requestCount, 1)
        defer atomic.AddInt32(&requestCount, -1)
        
        KingPage(w, r)
    })
    
    fmt.Println("服务器启动在 :8080")
    http.ListenAndServe(":8080", nil)
}

func HomePage(w http.ResponseWriter, r *http.Request) {
    currentCount := atomic.LoadInt32(&requestCount)
    fmt.Fprintf(w, "欢迎访问首页！当前并发请求数: %d", currentCount)
}

func KingPage(w http.ResponseWriter, r *http.Request) {
    currentCount := atomic.LoadInt32(&requestCount)
    fmt.Fprintf(w, "欢迎访问King页面！当前并发请求数: %d", currentCount)
}

这个实现中：

  • 使用带30个缓冲的通道sem作为信号量
  • 每个处理函数在开始时尝试向通道发送值（如果通道已满则阻塞）
  • 处理完成后从通道接收值释放一个位置
  • 使用原子操作atomic.AddInt32来安全地计数当前活跃请求数

这样就能确保最多只有30个请求同时被处理，其他请求会在通道缓冲区满时等待。

回到顶部