goroutine通过轻量级并发模型提升网络请求处理能力，为每个连接启动独立goroutine实现非阻塞处理；channel用于goroutine间通信与并发控制，如用缓冲channel限制最大并发数；通过context超时控制和读取超时设置可有效避免goroutine泄露。
Golang 使用 goroutine 和 channel 来处理高并发网络请求，核心在于其轻量级的并发模型和高效的调度机制，使得开发者能够以较低的成本构建高性能的网络服务。
Goroutine 是 Golang 中实现并发的核心机制。
如何利用 goroutine 提升网络请求处理能力？
首先，理解 Golang 的并发模型至关重要。不同于传统的线程模型，goroutine 是一种轻量级的执行单元，由 Go 运行时环境进行调度。这意味着你可以创建成千上万个 goroutine 而无需担心资源耗尽。关键在于，当一个 goroutine 阻塞（例如，等待 I/O）时，Go 运行时会将 CPU 切换到另一个可执行的 goroutine，从而避免了整个进程的阻塞。
在处理高并发网络请求时，一种常见的模式是为每个新的连接或请求启动一个 goroutine。这个 goroutine 负责处理该连接的整个生命周期，包括读取请求数据、处理业务逻辑、发送响应数据等。例如：
立即学习“go语言免费学习笔记（深入）”；
package main import ( "fmt" "net" ) func handleConnection(conn net.Conn) { defer conn.Close() buffer := make([]byte, 1024) for { n, err := conn.Read(buffer) if err != nil { fmt.Println("Connection closed:", err) return } fmt.Printf("Received: %s", buffer[:n]) // 处理请求... response := "OKn" conn.Write([]byte(response)) } } func main() { listener, err := net.Listen("tcp", ":8080") if err != nil { fmt.Println("Error listening:", err) return } defer listener.Close() fmt.Println("Server listening on :8080") for { conn, err := listener.Accept() if err != nil { fmt.Println("Error accepting:", err) continue } go handleConnection(conn) // 为每个连接启动一个 goroutine } }
这段代码展示了一个简单的 TCP 服务器，它为每个新的连接启动一个 goroutine 来处理。这样做的好处是，即使某个连接的处理时间较长，也不会阻塞其他连接的处理。
Channel 在高并发网络编程中扮演什么角色？
Channel 是 Golang 中用于 goroutine 之间通信的管道。在高并发网络编程中，channel 可以用来协调不同的 goroutine，传递数据，以及控制并发度。
例如，假设你需要限制同时处理的请求数量，可以使用 buffered channel 作为信号量。
package main import ( "fmt" "net" "sync" "time" ) var ( maxConcurrent = 10 sem = make(chan struct{}, maxConcurrent) wg sync.WaitGroup ) func handleConnection(conn net.Conn) { defer conn.Close() defer wg.Done() sem <- struct{}{} // 获取信号量 defer func() { <-sem }() // 释放信号量 buffer := make([]byte, 1024) for { n, err := conn.Read(buffer) if err != nil { fmt.Println("Connection closed:", err) return } fmt.Printf("Received: %s", buffer[:n]) // 模拟处理请求 time.Sleep(time.Second) response := "OKn" conn.Write([]byte(response)) } } func main() { listener, err := net.Listen("tcp", ":8080") if err != nil { fmt.Println("Error listening:", err) return } defer listener.Close() fmt.Println("Server listening on :8080") for { conn, err := listener.Accept() if err != nil { fmt.Println("Error accepting:", err) continue } wg.Add(1) go handleConnection(conn) } wg.Wait() }
在这个例子中，
sem
是一个 buffered channel，其容量限制了同时运行的 goroutine 数量。每个 goroutine 在开始处理请求之前，需要从
sem
中获取一个信号量；处理完成后，释放信号量。这样就保证了同时处理的请求数量不会超过
maxConcurrent
。
如何处理 goroutine 泄露？
Goroutine 泄露是指 goroutine 启动后，由于某些原因无法正常退出，导致资源占用持续增加。在高并发网络编程中，goroutine 泄露是一个常见的问题。
一个常见的导致 goroutine 泄露的原因是，goroutine 在等待某个 channel 上的数据，但该 channel 永远不会被关闭或发送数据。为了避免这种情况，可以使用
select
语句和
context
包来设置超时或取消信号。
package main import ( "context" "fmt" "net" "time" ) func handleConnection(ctx context.Context, conn net.Conn) { defer conn.Close() buffer := make([]byte, 1024) for { conn.SetReadDeadline(time.Now().Add(5 * time.Second)) // 设置读取超时 n, err := conn.Read(buffer) if err != nil { fmt.Println("Read error or timeout:", err) return } fmt.Printf("Received: %s", buffer[:n]) // 处理请求... response := "OKn" conn.Write([]byte(response)) select { case <-ctx.Done(): fmt.Println("Context cancelled, exiting goroutine") return default: // 继续处理 } } } func main() { listener, err := net.Listen("tcp", ":8080") if err != nil { fmt.Println("Error listening:", err) return } defer listener.Close() fmt.Println("Server listening on :8080") for { conn, err := listener.Accept() if err != nil { fmt.Println("Error accepting:", err) continue } ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() go handleConnection(ctx, conn) } }
在这个例子中，我们使用了
context.WithTimeout
创建了一个带有超时的 context。当 context 超时时，
ctx.Done()
channel 会被关闭，
handleConnection
函数中的
select
语句会检测到该信号，并退出 goroutine。此外，
conn.SetReadDeadline
设置了读取超时，避免了因连接长时间空闲而导致的阻塞。