Golang使用goroutine处理高并发网络请求-Golang-PHP中文网

Golang使用goroutine处理高并发网络请求

P粉602998670

发布： 2025-09-14 08:06:02

原创

346人浏览过

Goroutine通过轻量级并发模型提升网络请求处理能力，为每个连接启动独立goroutine实现非阻塞处理；channel用于goroutine间通信与并发控制，如用缓冲channel限制最大并发数；通过context超时控制和读取超时设置可有效避免goroutine泄露。

golang使用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，传递数据，以及控制并发度。

PatentPal专利申请写作

AI软件来为专利申请自动生成内容

查看详情

例如，假设你需要限制同时处理的请求数量，可以使用 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)
    }
}

登录后复制

在这个例子中，我们使用了