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 := "OK\n"
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 := "OK\n"
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 := "OK\n"
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设置了读取超时，避免了因连接长时间空闲而导致的阻塞。
