当前位置：首页 > 文章列表 > Golang > Go教程 > GolangUDP多线程收发实战详解

GolangUDP多线程收发实战详解

2025-09-29 23:47:30 0浏览收藏

Golang不知道大家是否熟悉？今天我将给大家介绍《Golang UDP多线程收发实战教程》，这篇文章主要会讲到等等知识点，如果你在看完本篇文章后，有更好的建议或者发现哪里有问题，希望大家都能积极评论指出，谢谢！希望我们能一起加油进步！

Go中UDP通信通过net.ListenPacket结合多Goroutine实现高并发，服务端用channel协调多个worker接收数据，客户端并发发送消息，共享的*net.UDPConn支持安全的并发读写，无需额外锁机制。

Golang UDP多线程接收与发送示例

在Go语言中，UDP通信本身是并发安全的，通过net.ListenPacket创建一个UDP监听套接字后，可以利用Goroutine实现多线程接收与发送。虽然Go的Goroutine不是传统意义上的“线程”，但其轻量特性非常适合高并发网络编程。下面是一个简单的Golang UDP多Goroutine接收与发送示例。

1. UDP服务端：多Goroutine接收数据

服务端启动后，监听指定端口，并使用多个Goroutine并发处理接收到的数据包。

package main
import (
"fmt"
"net"
"time"
)
const numWorkers = 3 // 启动3个接收协程
func handlePacket(conn net.UDPConn, data []byte, addr net.UDPAddr) {
fmt.Printf("来自 %s 的消息: %s\n", addr.String(), string(data))
// 模拟响应
response := "收到: " + string(data)
conn.WriteToUDP([]byte(response), addr)
}
func worker(id int, conn net.UDPConn, packets chan net.UDPAddr) {
buffer := make([]byte, 1024)
fmt.Printf("worker-%d 开始监听\n", id)
for range packets {
    n, addr, err := conn.ReadFromUDP(buffer)
    if err != nil {
        fmt.Printf("worker-%d 读取错误: %v\n", id, err)
        continue
    }

    // 复制数据，避免后续读取覆盖
    data := make([]byte, n)
    copy(data, buffer[:n])

    go handlePacket(conn, data, addr)
}
}
func main() {
addr, _ := net.ResolveUDPAddr("udp", ":8080")
conn, err := net.ListenUDP("udp", addr)
if err != nil {
panic(err)
}
defer conn.Close()
// 使用channel通知worker继续接收
packets := make(chan *net.UDPAddr, 100)

// 启动多个worker
for i := 0; i < numWorkers; i++ {
    go worker(i, conn, packets)
}

fmt.Println("UDP服务器正在运行在 :8080...")

// 持续发送事件到任意worker（轮询方式）
for {
    packets <- nil // 触发任一worker去调用ReadFromUDP
    time.Sleep(time.Microsecond) // 避免忙等
}
}

2. UDP客户端：并发发送消息

客户端使用多个Goroutine向服务端发送UDP消息，模拟高并发场景。

package main
import (
"fmt"
"net"
"sync"
"time"
)
func sendMsg(id int, serverAddr net.UDPAddr, wg sync.WaitGroup) {
defer wg.Done()
conn, err := net.DialUDP("udp", nil, serverAddr)
if err != nil {
    fmt.Printf("客户端 %d 连接失败: %v\n", id, err)
    return
}
defer conn.Close()

for i := 0; i < 5; i++ {
    msg := fmt.Sprintf("客户端-%d 发送消息-%d", id, i+1)
    conn.Write([]byte(msg))

    // 接收响应
    buffer := make([]byte, 1024)
    n, err := conn.Read(buffer)
    if err != nil {
        fmt.Printf("客户端 %d 读取失败: %v\n", id, err)
    } else {
        fmt.Printf("客户端-%d 收到响应: %s\n", id, string(buffer[:n]))
    }

    time.Sleep(100 * time.Millisecond)
}
}
func main() {
serverAddr, _ := net.ResolveUDPAddr("udp", "127.0.0.1:8080")
var wg sync.WaitGroup
// 启动10个并发客户端
for i := 0; i < 10; i++ {
    wg.Add(1)
    go sendMsg(i+1, serverAddr, &wg)
    time.Sleep(10 * time.Millisecond) // 避免瞬间连接风暴
}

wg.Wait()
fmt.Println("所有客户端发送完成")
}

3. 关键说明与注意事项

该设计展示了如何在Go中实现UDP的“多线程”通信模式，实际使用中需注意以下几点：

UDP无连接：每个WriteToUDP都需要指定目标地址，适合一对一或广播场景。
Goroutine调度：多个Goroutine调用ReadFromUDP时，Go运行时会自动处理并发，但不能多个同时阻塞读同一个连接。
共享Socket：服务端只有一个*net.UDPConn，多个worker通过channel协调读取，避免竞争。
数据拷贝：在Goroutine中处理前应复制buffer内容，防止主缓冲区被覆盖。
错误处理：UDP不保证送达，程序需容忍丢包、乱序等情况。

4. 简化单协程接收 + 多协程发送

更常见做法是服务端用单个循环接收，再分发给多个处理协程，结构更清晰：

// 简化版服务端接收逻辑
for {
    buffer := make([]byte, 1024)
    n, addr, err := conn.ReadFromUDP(buffer)
    if err != nil {
        continue
    }
    data := make([]byte, n)
    copy(data, buffer[:n])
    go handlePacket(conn, data, addr) // 分发给worker处理
}

基本上就这些。Go的UDP编程结合Goroutine非常简洁高效，无需复杂锁机制即可实现高性能并发通信。关键是理解*net.UDPConn是线程安全的读写操作，合理分配任务即可。

好了，本文到此结束，带大家了解了《GolangUDP多线程收发实战详解》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！