讲师中心 微信公众号
首页
文章
后端开发 web前端 数据库 开发工具 php框架 常见问题 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 自媒体 新闻
专题
后端开发 web前端 数据库 开发工具 php框架 科技 Java 系统教程 电脑教程 硬件教程 手机教程 软件教程 游戏教程 新闻
AI工具
AI 聊天问答 Agent智能体 AI 文本写作 AI 绘画作图 AI 设计工具 AI 视频创作 AI 音频制作 AI 办公学习 AI 编程开发 Prompt指令
学习
大前端 后端开发 数据库 移动端 运维开发 计算机基础
编程手册
大前端 后端开发 数据库 移动端 运维开发 计算机基础
下载
js特效 网站源码 工具下载 类库下载 网站素材 学习资源 插件扩展 手机游戏
最近更新
当前位置：首页 > 后端开发 > Golang >

正文

0

0

GolangTCP数据包发送与接收示例

P粉602998670

P粉602998670

发布时间：2025-09-18 10:40:02

|

219人浏览过

|

来源于php中文网

原创

答案：通过Go语言实现TCP通信，使用消息头携带长度信息解决粘包拆包问题，结合goroutine池和多路复用提升高并发性能，并通过心跳检测与日志记录保障连接可靠性。

golangtcp数据包发送与接收示例

Golang TCP数据包发送与接收，简单来说，就是用Go语言实现客户端和服务端通过TCP协议进行数据通信。下面给出一个基本的示例，展示如何发送和接收数据包。

// 服务端
package main

import (
    "fmt"
    "net"
    "os"
)

const (
    SERVER_HOST = "localhost"
    SERVER_PORT = "9988"
    SERVER_TYPE = "tcp"
)

func main() {
    fmt.Println("Server Running...")
    server, err := net.Listen(SERVER_TYPE, SERVER_HOST+":"+SERVER_PORT)
    if err != nil {
        fmt.Println("Error listening:", err.Error())
        os.Exit(1)
    }
    defer server.Close()
    fmt.Println("Listening on " + SERVER_HOST + ":" + SERVER_PORT)
    fmt.Println("Waiting for client...")
    for {
        connection, err := server.Accept()
        if err != nil {
            fmt.Println("Error accept:", err.Error())
            return
        }
        fmt.Println("Client connected")
        go processClient(connection)
    }
}

func processClient(connection net.Conn) {
    buffer := make([]byte, 1024)
    mLen, err := connection.Read(buffer)
    if err != nil {
        fmt.Println("Error reading:", err.Error())
        return
    }
    fmt.Println("Received: ", string(buffer[:mLen]))
    _, err = connection.Write([]byte("Message received."))
    if err != nil {
        fmt.Println("Error writing:", err.Error())
        return
    }
    connection.Close()
}

// 客户端
package main

import (
    "fmt"
    "net"
    "os"
)

const (
    SERVER_HOST = "localhost"
    SERVER_PORT = "9988"
    SERVER_TYPE = "tcp"
)

func main() {
    connection, err := net.Dial(SERVER_TYPE, SERVER_HOST+":"+SERVER_PORT)
    if err != nil {
        fmt.Println("Error dialing:", err.Error())
        os.Exit(1)
    }
    defer connection.Close()

    fmt.Println("Connected to server")
    _, err = connection.Write([]byte("Hello Server!"))
    if err != nil {
        fmt.Println("Error writing:", err.Error())
        os.Exit(1)
    }

    buffer := make([]byte, 1024)
    mLen, err := connection.Read(buffer)
    if err != nil {
        fmt.Println("Error reading:", err.Error())
        os.Exit(1)
    }

    fmt.Println("Received: ", string(buffer[:mLen]))
}

如何处理TCP连接中的粘包和拆包问题？

TCP是面向流的协议，这意味着数据在传输过程中可能会发生粘包和拆包。简单来说，粘包就是多个小数据包被合并成一个大数据包发送，而拆包就是一个大数据包被拆分成多个小数据包发送。

解决粘包和拆包的常见方法有：

  1. 固定长度消息： 每个数据包都使用固定长度，接收方按照固定长度读取数据。这实现简单，但不够灵活，浪费带宽。

    立即学习“go语言免费学习笔记（深入）”；

  2. 使用分隔符： 在每个数据包的末尾添加一个特殊的分隔符，接收方通过查找分隔符来分割数据包。例如，使用换行符

    \n
    作为分隔符。

  3. 消息头包含长度信息： 在每个数据包的头部添加一个字段，用于表示数据包的长度。接收方首先读取头部，获取数据包长度，然后按照长度读取数据。这是最常用的方法，也比较灵活。

下面是一个使用消息头包含长度信息的示例：

// 服务端 (修改后的 processClient 函数)
func processClient(connection net.Conn) {
    for {
        headerBuffer := make([]byte, 4) // 假设长度信息使用 4 字节
        _, err := connection.Read(headerBuffer)
        if err != nil {
            fmt.Println("Error reading header:", err)
            return
        }

        messageLength := binary.BigEndian.Uint32(headerBuffer) // 将字节转换为 uint32

        messageBuffer := make([]byte, messageLength)
        _, err = connection.Read(messageBuffer)
        if err != nil {
            fmt.Println("Error reading message:", err)
            return
        }

        fmt.Println("Received:", string(messageBuffer))

        // 发送响应
        response := "Message received."
        responseBytes := []byte(response)
        responseLength := uint32(len(responseBytes))

        responseHeader := make([]byte, 4)
        binary.BigEndian.PutUint32(responseHeader, responseLength)

        _, err = connection.Write(responseHeader)
        if err != nil {
            fmt.Println("Error writing response header:", err)
            return
        }

        _, err = connection.Write(responseBytes)
        if err != nil {
            fmt.Println("Error writing response:", err)
            return
        }
    }
}

// 客户端 (修改后的 main 函数)
func main() {
    connection, err := net.Dial(SERVER_TYPE, SERVER_HOST+":"+SERVER_PORT)
    if err != nil {
        fmt.Println("Error dialing:", err.Error())
        os.Exit(1)
    }
    defer connection.Close()

    fmt.Println("Connected to server")

    message := "Hello Server! This is a longer message."
    messageBytes := []byte(message)
    messageLength := uint32(len(messageBytes))

    header := make([]byte, 4)
    binary.BigEndian.PutUint32(header, messageLength) // 将长度转换为字节

    _, err = connection.Write(header)
    if err != nil {
        fmt.Println("Error writing header:", err)
        os.Exit(1)
    }

    _, err = connection.Write(messageBytes)
    if err != nil {
        fmt.Println("Error writing message:", err)
        os.Exit(1)
    }

    // 读取响应
    headerBuffer := make([]byte, 4)
    _, err = connection.Read(headerBuffer)
    if err != nil {
        fmt.Println("Error reading response header:", err)
        os.Exit(1)
    }

    responseLength := binary.BigEndian.Uint32(headerBuffer)
    responseBuffer := make([]byte, responseLength)

    _, err = connection.Read(responseBuffer)
    if err != nil {
        fmt.Println("Error reading response:", err)
        os.Exit(1)
    }

    fmt.Println("Received:", string(responseBuffer))
}

这个示例中，使用了 

encoding/binary
包来处理字节序。客户端和服务端都先发送一个 4 字节的头部，表示消息的长度，然后再发送消息内容。

如何处理高并发TCP连接？

在高并发场景下，单个goroutine处理一个连接的方式效率较低。可以使用goroutine池来复用goroutine，或者使用epoll等多路复用技术来提高性能。

  1. Goroutine 池： 预先创建一组goroutine，并将连接分配给这些goroutine处理。这样可以避免频繁创建和销毁goroutine的开销。

    Extjs简单版酒店管理系统 bulid 081016
    Extjs简单版酒店管理系统 bulid 081016

    该系统采用VS2005+SQL2000+Extjs2.0开发由于学extjs 一月不到 属初学者，项目有很多不足地方请见谅(注释不标准按自己想法随意注释了一下)数据库脚本:压缩包目录下.DB.sql便是该项目为双用户：管理员 与营业员 角色登陆显示不同信息数据库方面一小部分功能运用存储过程或者直接附加DB_51aspx下Sql数据库文件

    下载

  2. 多路复用 (epoll, kqueue)： 使用操作系统提供的多路复用机制，可以在单个goroutine中同时监听多个socket连接。Go语言的

    net
    包已经封装了这些机制，可以直接使用。

一个简单的goroutine池的实现思路：

package main

import (
    "fmt"
    "net"
    "os"
    "sync"
)

const (
    SERVER_HOST = "localhost"
    SERVER_PORT = "9988"
    SERVER_TYPE = "tcp"
    POOL_SIZE   = 10 // Goroutine池大小
)

type Job struct {
    Conn net.Conn
}

var jobQueue chan Job

func worker(jobQueue chan Job, wg *sync.WaitGroup) {
    defer wg.Done()

    for job := range jobQueue {
        processConnection(job.Conn)
    }
}

func processConnection(conn net.Conn) {
    defer conn.Close()

    buffer := make([]byte, 1024)
    mLen, err := conn.Read(buffer)
    if err != nil {
        fmt.Println("Error reading:", err.Error())
        return
    }
    fmt.Println("Received: ", string(buffer[:mLen]))
    _, err = conn.Write([]byte("Message received."))
    if err != nil {
        fmt.Println("Error writing:", err.Error())
        return
    }
}

func main() {
    fmt.Println("Server Running...")
    server, err := net.Listen(SERVER_TYPE, SERVER_HOST+":"+SERVER_PORT)
    if err != nil {
        fmt.Println("Error listening:", err.Error())
        os.Exit(1)
    }
    defer server.Close()
    fmt.Println("Listening on " + SERVER_HOST + ":" + SERVER_PORT)
    fmt.Println("Waiting for client...")

    jobQueue = make(chan Job, 100) // 缓冲大小为 100

    var wg sync.WaitGroup

    // 启动 goroutine 池
    for i := 0; i < POOL_SIZE; i++ {
        wg.Add(1)
        go worker(jobQueue, &wg)
    }

    for {
        connection, err := server.Accept()
        if err != nil {
            fmt.Println("Error accept:", err.Error())
            return
        }
        fmt.Println("Client connected")

        jobQueue <- Job{Conn: connection} // 将连接放入 jobQueue
    }

    close(jobQueue) // 关闭 jobQueue
    wg.Wait()        // 等待所有 worker 完成
}

这个例子中，创建了一个固定大小的goroutine池，每个连接都作为一个

Job
放入
jobQueue
中，由goroutine池中的worker来处理。

如何进行错误处理和日志记录？

错误处理是TCP编程中非常重要的一部分。需要对各种可能出现的错误进行处理，例如连接错误、读取错误、写入错误等。同时，为了方便调试和排查问题，需要进行日志记录。

  1. 错误处理： 使用

    if err != nil
    来检查错误，并根据错误类型进行处理。例如，可以关闭连接、记录日志、返回错误信息等。

  2. 日志记录： 使用

    log
    包或者第三方日志库（如
    logrus
    、
    zap
    ）来记录日志。日志级别可以分为debug、info、warn、error等，根据需要选择合适的日志级别。

package main

import (
    "fmt"
    "log"
    "net"
    "os"
    "time"
)

const (
    SERVER_HOST = "localhost"
    SERVER_PORT = "9988"
    SERVER_TYPE = "tcp"
)

func main() {
    // 初始化日志
    logFile, err := os.OpenFile("server.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        fmt.Println("Error opening log file:", err)
        os.Exit(1)
    }
    defer logFile.Close()
    log.SetOutput(logFile)
    log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)

    fmt.Println("Server Running...")
    server, err := net.Listen(SERVER_TYPE, SERVER_HOST+":"+SERVER_PORT)
    if err != nil {
        log.Println("Error listening:", err.Error())
        os.Exit(1)
    }
    defer server.Close()
    fmt.Println("Listening on " + SERVER_HOST + ":" + SERVER_PORT)
    fmt.Println("Waiting for client...")
    for {
        connection, err := server.Accept()
        if err != nil {
            log.Println("Error accept:", err.Error())
            continue // 继续监听
        }
        fmt.Println("Client connected")
        go processClient(connection)
    }
}

func processClient(connection net.Conn) {
    defer connection.Close()

    buffer := make([]byte, 1024)
    connection.SetReadDeadline(time.Now().Add(10 * time.Second)) // 设置读取超时
    mLen, err := connection.Read(buffer)
    if err != nil {
        log.Println("Error reading:", err.Error())
        return
    }
    log.Printf("Received: %s from %s\n", string(buffer[:mLen]), connection.RemoteAddr().String())

    _, err = connection.Write([]byte("Message received."))
    if err != nil {
        log.Println("Error writing:", err.Error())
        return
    }
}

这个例子中，使用了

log
包将日志记录到文件中。同时，使用
SetReadDeadline
设置了读取超时，防止连接一直阻塞。

如何实现心跳检测？

心跳检测用于检测客户端和服务端之间的连接是否仍然有效。客户端定期向服务端发送心跳包，服务端如果在一定时间内没有收到心跳包，则认为连接已断开。

// 服务端 (修改后的 processClient 函数)
func processClient(connection net.Conn) {
    defer connection.Close()

    for {
        connection.SetReadDeadline(time.Now().Add(30 * time.Second)) // 设置读取超时为 30 秒
        buffer := make([]byte, 1024)
        mLen, err := connection.Read(buffer)
        if err != nil {
            log.Println("Error reading:", err.Error())
            return // 连接超时或发生错误，退出循环
        }

        message := string(buffer[:mLen])
        if message == "heartbeat" {
            log.Println("Received heartbeat from", connection.RemoteAddr())
            // 可以选择发送一个响应，表示收到心跳
            _, err = connection.Write([]byte("heartbeat_ack"))
            if err != nil {
                log.Println("Error writing heartbeat ack:", err.Error())
                return
            }
        } else {
            log.Printf("Received: %s from %s\n", message, connection.RemoteAddr().String())
            _, err = connection.Write([]byte("Message received."))
            if err != nil {
                log.Println("Error writing:", err.Error())
                return
            }
        }
    }
}

// 客户端 (修改后的 main 函数)
func main() {
    connection, err := net.Dial(SERVER_TYPE, SERVER_HOST+":"+SERVER_PORT)
    if err != nil {
        fmt.Println("Error dialing:", err.Error())
        os.Exit(1)
    }
    defer connection.Close()

    fmt.Println("Connected to server")

    // 定期发送心跳
    ticker := time.NewTicker(10 * time.Second) // 每 10 秒发送一次心跳
    defer ticker.Stop()

    for range ticker.C {
        _, err := connection.Write([]byte("heartbeat"))
        if err != nil {
            fmt.Println("Error writing heartbeat:", err.Error())
            return // 连接断开，退出循环
        }
        fmt.Println("Sent heartbeat")

        // 可以选择读取服务器的响应
        buffer := make([]byte, 1024)
        connection.SetReadDeadline(time.Now().Add(5 * time.Second)) // 设置读取超时
        _, err = connection.Read(buffer)

        if err != nil {
            fmt.Println("Error reading heartbeat ack:", err.Error())
            // 可以选择重试或者退出
            continue
        }
        fmt.Println("Received heartbeat ack:", string(buffer))

    }
}

在这个例子中，客户端每10秒发送一次心跳包，服务端如果在30秒内没有收到心跳包，则认为连接已断开。客户端也设置了读取超时，防止一直阻塞。

这些示例代码只是最基本的实现，实际应用中还需要根据具体需求进行修改和完善。例如，可以添加更完善的错误处理、日志记录、数据校验等功能。

相关文章

如何使用Golang实现微服务灰度发布_Golang微服务灰度策略实践

如何在Golang中实现状态机_Golang状态模式流程控制示例

如何在Linux上安装Golang_Linux系统Golang安装与配置方法

如何在Golang中使用panic和recover_Golang异常处理基础

如何在Golang中实现服务限流与熔断_Golang微服务流量控制方法

相关标签:

golang go 操作系统 go语言 大数据 app 字节 ai golang if 封装 Error Go语言 nil 并发

本站声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn

上一篇：深入理解Go语言中select与default的调度行为 下一篇：Go语言中访问C语言Union字段的原理与实践

作者最新文章

edge浏览器自动启动怎么关 edge浏览器启动项管理

2026-01-23 17:36

Safari浏览器如何截图网页 Safari浏览器截图技巧讲解

2026-01-23 17:39

ChatGPT在线网页入口地址 ChatGPT官方访问说明

2026-01-23 17:40

ChatGPT无法识别复杂的统计图表数据_将图表截屏上传并要求其先转换为CSV格式

2026-01-23 17:41

edge浏览器页面显示异常 edge浏览器渲染修复方法

2026-01-23 17:41

ChatGPT网页端官方地址 ChatGPT在线访问入口

2026-01-23 17:43

UC浏览器字体大小怎么调 UC浏览器显示设置说明

2026-01-23 17:44

ChatGPT如何根据网页链接写总结_确认已开启联网功能并直接粘贴URL要求提取重点

2026-01-23 17:46

Windows10如何禁用驱动签名_Win10高级启动设置选项

2026-01-23 17:53

宙斯浏览器官网主页地址 Zeus浏览器在线访问入口

2026-01-23 17:56

热门AI工具

更多
DeepSeek

DeepSeek

幻方量化公司旗下的开源大模型平台

AI大模型

开放平台
豆包大模型

豆包大模型

字节跳动自主研发的一系列大型语言模型

AI大模型
通义千问

通义千问

阿里巴巴推出的全能AI助手

AI大模型
腾讯元宝

腾讯元宝

腾讯混元平台推出的AI助手

文档处理

Excel 表格
文心一言

文心一言

文心一言是百度开发的AI聊天机器人，通过对话可以生成各种形式的内容。

AI大模型

中文写作
讯飞写作

讯飞写作

基于讯飞星火大模型的AI写作工具，可以快速生成新闻稿件、品宣文案、工作总结、心得体会等各种文文稿

中文写作

写作工具
即梦AI

即梦AI

一站式AI创作平台，免费AI图片和视频生成。

图片拼接

图画生成
ChatGPT

ChatGPT

最最强大的AI聊天机器人程序，ChatGPT不单是聊天机器人，还能进行撰写邮件、视频脚本、文案、翻译、代码等任务。

AI大模型

中文写作
智谱清言 - 免费全能的AI助手

智谱清言 - 免费全能的AI助手

智谱清言 - 免费全能的AI助手

AI大模型

PC软件

相关专题

更多
golang如何定义变量
golang如何定义变量

golang定义变量的方法：1、声明变量并赋予初始值“var age int =值”；2、声明变量但不赋初始值“var age int”；3、使用短变量声明“age :=值”等等。本专题为大家提供相关的文章、下载、课程内容，供大家免费下载体验。

180

2024.02.23

golang有哪些数据转换方法
golang有哪些数据转换方法

golang数据转换方法：1、类型转换操作符；2、类型断言；3、字符串和数字之间的转换；4、JSON序列化和反序列化；5、使用标准库进行数据转换；6、使用第三方库进行数据转换；7、自定义数据转换函数。本专题为大家提供相关的文章、下载、课程内容，供大家免费下载体验。

228

2024.02.23

golang常用库有哪些
golang常用库有哪些

golang常用库有：1、标准库；2、字符串处理库；3、网络库；4、加密库；5、压缩库；6、xml和json解析库；7、日期和时间库；8、数据库操作库；9、文件操作库；10、图像处理库。本专题为大家提供相关的文章、下载、课程内容，供大家免费下载体验。

341

2024.02.23

golang和python的区别是什么
golang和python的区别是什么

golang和python的区别是：1、golang是一种编译型语言，而python是一种解释型语言；2、golang天生支持并发编程，而python对并发与并行的支持相对较弱等等。本专题为大家提供相关的文章、下载、课程内容，供大家免费下载体验。

209

2024.03.05

golang是免费的吗
golang是免费的吗

golang是免费的。golang是google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的开源编程语言，采用bsd开源协议。本专题为大家提供相关的文章、下载、课程内容，供大家免费下载体验。

393

2024.05.21

golang结构体相关大全
golang结构体相关大全

本专题整合了golang结构体相关大全，想了解更多内容，请阅读专题下面的文章。

198

2025.06.09

golang相关判断方法
golang相关判断方法

本专题整合了golang相关判断方法，想了解更详细的相关内容，请阅读下面的文章。

191

2025.06.10

golang数组使用方法
golang数组使用方法

本专题整合了golang数组用法，想了解更多的相关内容，请阅读专题下面的文章。

273

2025.06.17

c++空格相关教程合集
c++空格相关教程合集

本专题整合了c++空格相关教程，阅读专题下面的文章了解更多详细内容。

0

2026.01.23

热门下载

更多
网站特效
/
网站源码
/
网站素材
/
前端模板

相关下载

更多
Extjs简单版酒店管理系统 bulid 081016
电子黄页系统
电子商务订货系统订货宝

精品课程

更多
相关推荐
/
热门推荐
/
最新课程
golang socket 编程
golang socket 编程

共2课时 | 0.1万人学习

nginx浅谈
nginx浅谈

共15课时 | 0.8万人学习

golang和swoole核心底层分析
golang和swoole核心底层分析

共3课时 | 0.1万人学习

最新文章

更多
如何在Golang中实现简单的图表生成_Golang image与绘图方法实践
如何在Golang中使用私有仓库_Golang模块私有源配置与访问方法
如何将 Go 脚本编译为可直接调用的 Shell 命令
如何验证 Go 包及其测试能否成功编译（不运行测试、不生成持久二进制文件）
如何使用Golang实现服务调用链追踪_Golang微服务调用链监控方法
如何在Golang中处理文件路径错误_Golang路径不存在及权限异常处理
如何使用Golang实现模块化开发_Golang多模块项目结构管理
如何使用Golang实现微服务灰度发布_Golang微服务灰度策略实践
Go并发编程中mutex如何使用_Go互斥锁用法解析
如何在Golang中实现状态机_Golang状态模式流程控制示例
关于我们 免责申明 举报中心 意见反馈 讲师合作 广告合作 最新更新
php中文网：公益在线php培训，帮助PHP学习者快速成长！
关注服务号 技术交流群
PHP中文网订阅号
每天精选资源文章推送

Copyright 2014-2026 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号

  • PHP学习

  • 技术支持

  • 返回顶部