2025-05-04 Unity 网络基础6——TCP心跳消息

已于 2025-05-04 10:01:50 修改
阅读量522 收藏 7
点赞数 3
分类专栏： Unity 学习 文章标签： 网络 unity tcp/ip
于 2025-05-04 10:00:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zheliku/article/details/147691790
版权

文章目录


​ 在客户端主动退出时，我们会调用 socket 的 ShutDown() 和 Close() 方法，但调用这两个方法后，服务器端无法得知客户端已经主动断开。

​ 本文主要介绍在网络通信中，如何服务端如何判断客户端断开连接。

1 Disconnect 方法

​ Socket 当中有一个专门在客户端使用的方法：Disconnect 方法。

  • 此方法将结束连接并将 Connected 属性设置为 false。但是，如果 reuseSocket 为 true，则可以重用套接字。
  • 若要确保在关闭套接字之前发送和接收所有数据，应在调用 Disconnect 方法之前调用 Shutdown。

客户端

​ 在程序退出时，主动断开连接。

public class NetManager : MonoBehaviour
{
    ...
        
    public void OnDestroy()
    {
        if (_socket != null)
        {
            Debug.Log("客户端主动断开连接...");

            _isConnected = false;
            _socket.Shutdown(SocketShutdown.Both);
            _socket.Disconnect(false);
            _socket.Close();
            _socket = null;
        }
    }
    
    ...
}

服务端

  1. 收发消息时判断 socket 是否已经断开。

    namespace NetLearningTcpServerExercise2;

using System.Net.Sockets;

public class ClientSocket
{
    private static int _ClientBeginId = 1;

    private Socket _socket;

    private byte[] _cacheBytes = new byte[1024 * 1024]; // 缓冲区，大小为 1MB
    private int    _cacheBytesLength;

    public int Id;
    
    public bool Connected
    {
        get => _socket == null ? false : _socket.Connected;
    }
    
    ...

    public void ReceiveMessage()
    {
        if (!Connected) // 判断是否连接
        {
            Program.ServerSocket.AddDelSocket(this);
            return;
        }

        try
        {
            if (_socket.Available > 0)
            {
                var buffer        = new byte[1024 * 5];
                var receiveLength = _socket.Receive(buffer);
                HandleReceiveMessage(buffer, receiveLength);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("ReceiveMessage Wrong: " + e);

            Program.ServerSocket.AddDelSocket(this); // 解析错误，也认为把消息断开
        }
    }
    
    ...
}

  2. 处理删除记录的 socket 的相关逻辑（使用线程锁）。

namespace NetLearningTcpServerExercise2;

using System.Net;
using System.Net.Sockets;

public class ServerSocket
{
    private readonly Socket _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

    private Dictionary<int, ClientSocket> _clientSockets = new Dictionary<int, ClientSocket>();

    private List<ClientSocket> _delList = new List<ClientSocket>(); // 待移除列表

    private bool _Running;
    
    ...

    private void ReceiveMessage(object? state)
    {
        while (_Running)
        {
            lock (_clientSockets)
            {
                if (_clientSockets.Count > 0)
                {
                    foreach (var clientSocket in _clientSockets.Values)
                    {
                        clientSocket.ReceiveMessage();
                    }

                    ClearDelSocket(); // 每次循环，检查是否有待移除的 socket
                }
            }
        }
    }

    private void ClearDelSocket()
    {
        // 移除
        for (int i = 0; i < _delList.Count; i++)
        {
            CloseClientSocket(_delList[i]);
        }
        _delList.Clear();
    }

    public void CloseClientSocket(ClientSocket socket)
    {
        lock (_clientSockets)
        {
            Console.WriteLine("ClientSocket Close: " + socket.Id);
            _clientSockets.Remove(socket.Id);
            socket.Close();
        }
    }

    public void AddDelSocket(ClientSocket socket)
    {
        if (!_delList.Contains(socket))
        {
            _delList.Add(socket);
            // Console.WriteLine(socket);
        }
    }
}

测试

​ 启动服务器后，运行 Unity 并立刻结束运行，服务器中可以看到如下消息：

image-20250504092837596

2 心跳消息

​ 很多情况下，客户端并不会像上述一样正常断开连接。例如

  1. 非正常关闭客户端时，服务器无法正常收到关闭连接消息。
  2. 客户端长期不发送消息，防火墙或者路由器会断开连接。

​ 因此，在长连接中，客户端和服务端之间会定期发送的一种特殊数据包，用于通知对方自己还在线，以确保长连接的有效性。

​ 由于其发送的时间间隔往往是固定的持续的，就像是心跳一样一直存在，所以我们称之为**“心跳消息”**。

客户端

  1. 定义心跳消息

     public class HeartMessage : INetMessage
{
    public int MessageId { get => 999; }

    public int BytesLength { get => sizeof(int) + sizeof(int); }

    public byte[] ToBytes()
    {
        var length = BytesLength;
        var bytes  = new byte[length];
        var index  = 0;
        index = this.Write(bytes, index, MessageId);

        // 写入消息长度
        index = this.Write(bytes, index, length - sizeof(int) * 2); // 减去消息长度和消息 Id 的长度
        return bytes;
    }

    public int FromBytes(byte[] bytes, int index)
    {
        return index;
    }
}

  2. 定时发送消息。

    public class NetManager : MonoBehaviour
{
    public static NetManager Instance { get; private set; }

    private Socket _socket;

    /// <summary>
    /// 发送消息的公共队列，主线程塞消息，发送线程拿消息进行发送
    /// </summary>
    private Queue<INetMessage> _sendMessages = new Queue<INetMessage>();

    /// <summary>
    /// 接收消息的公共队列，主线程拿消息，接收线程获取消息塞进去
    /// </summary>
    private Queue<INetMessage> _receiveMessages = new Queue<INetMessage>();

    private bool _isConnected
    {
        get => _socket == null ? false : _socket.Connected;
    }

    private byte[] _cacheBytes = new byte[1024 * 1024]; // 缓冲区，大小为 1MB
    private int    _cacheBytesLength;

    private static readonly int _SEND_HEART_MSG_TIME = 2;

    private void Awake()
    {
        Instance = this;

        // 循环定时给服务端发送心跳消息
        InvokeRepeating(nameof(SendHeartMsg), 0, _SEND_HEART_MSG_TIME);
    }
    
    public void SendHeartMsg()
    {
        if (_isConnected)
        {
            Send(new HeartMessage());
        }
        Debug.Log("发送心跳消息: " + _isConnected);
    }
    
    ...
}

服务器

​ 不停检测上次收到某客户端消息的时间，如果超时则认为连接已经断开

namespace NetLearningTcpServerExercise2;

using System.Net.Sockets;

public class ClientSocket
{
    private static int _ClientBeginId = 1;

    private Socket _socket;

    private byte[] _cacheBytes = new byte[1024 * 1024]; // 缓冲区，大小为 1MB
    private int    _cacheBytesLength;

    public int Id;

    private        long _frontTime     = -1; // 上次收到的心跳时间
    private static int  _TIME_OUT_TIME = 5;

    public bool Connected
    {
        get => _socket == null ? false : _socket.Connected;
    }

    public ClientSocket(Socket socket)
    {
        Id      = _ClientBeginId++;
        _socket = socket;

        ThreadPool.QueueUserWorkItem(CheckTimeOut, null);
    }

    /// <summary>
    /// 间隔一段时间检测超时
    /// </summary>
    /// <param name="state"></param>
    private void CheckTimeOut(object? state)
    {
        while (Connected)
        {
            if (_frontTime != -1 &&
                DateTime.Now.Ticks / TimeSpan.TicksPerSecond - _frontTime > _TIME_OUT_TIME)
            {
                Program.ServerSocket.AddDelSocket(this);
                break;
            }

            Thread.Sleep(1000);
        }
    }

    public void Close()
    {
        if (_socket != null)
        {
            _socket.Shutdown(SocketShutdown.Both);
            _socket.Close();
            _socket = null!;
        }
    }

    public void SendMessage(INetMessage message)
    {
        if (!Connected)
        {
            Program.ServerSocket.AddDelSocket(this);
            return;
        }

        try
        {
            _socket.Send(message.ToBytes());
        }
        catch (Exception e)
        {
            Console.WriteLine("SendMessage Wrong: " + e);

            Program.ServerSocket.AddDelSocket(this);
        }
    }

    public void ReceiveMessage()
    {
        if (!Connected)
        {
            Program.ServerSocket.AddDelSocket(this);
            return;
        }

        try
        {
            if (_socket.Available > 0)
            {
                var buffer        = new byte[1024 * 5];
                var receiveLength = _socket.Receive(buffer);
                HandleReceiveMessage(buffer, receiveLength);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("ReceiveMessage Wrong: " + e);

            Program.ServerSocket.AddDelSocket(this); // 解析错误，也认为把消息断开
        }
    }

    private void MessageHandle(object? state)
    {
        if (state == null) return;

        var msg = (INetMessage) state;
        if (msg is PlayerMessage playerMsg)
        {
            Console.WriteLine($"Receive message from client {_socket} (ID {Id}): {playerMsg}");
        }
        else if (msg is QuitMessage quitMsg)
        {
            Program.ServerSocket.AddDelSocket(this); // 客户端断开连接
        }
        else if (msg is HeartMessage heartMsg)
        {
            _frontTime = DateTime.Now.Ticks / TimeSpan.TicksPerSecond;

            Console.WriteLine($"Receive heart message from client {_socket} (ID {Id}): {heartMsg}");
        }
    }

    private void HandleReceiveMessage(byte[] receiveBytes, int receiveNum)
    {
        var messageId = 0;
        var index     = 0;

        // 收到消息时看之前有没有缓存
        // 如果有，直接拼接到后面
        receiveBytes.CopyTo(_cacheBytes, _cacheBytesLength);
        _cacheBytesLength += receiveNum;

        while (true)
        {
            var messageLength = -1;

            // 处理前置信息
            if (_cacheBytesLength - index >= 8)
            {
                // 解析 Id
                messageId =  BitConverter.ToInt32(_cacheBytes, index);
                index     += sizeof(int);

                // 解析长度
                messageLength =  BitConverter.ToInt32(_cacheBytes, index);
                index         += sizeof(int);
            }

            // 处理消息体
            if (messageLength != -1 && _cacheBytesLength - index >= messageLength)
            {
                // 解析消息体
                INetMessage message = default;
                switch (messageId)
                {
                    case 1001:
                        message = new PlayerMessage();
                        message.FromBytes(_cacheBytes, index);
                        break;
                    case 1003:
                        message = new QuitMessage();
                        message.FromBytes(_cacheBytes, index);
                        break;
                    case 999:
                        message = new HeartMessage();
                        message.FromBytes(_cacheBytes, index);
                        break;
                }

                if (message != default)
                {
                    ThreadPool.QueueUserWorkItem(MessageHandle, message);
                }
                index += messageLength;

                // 如果消息体长度等于缓存长度，证明缓存已经处理完毕
                if (index == _cacheBytesLength)
                {
                    _cacheBytesLength = 0;
                    break;
                }
            }
            else // 消息体还没有接收完毕
            {
                // 解析了前置信息，但是没有成功解析消息体
                if (messageLength != -1)
                {
                    index -= 8; // 回退到解析 Id 的位置
                }

                // 缓存剩余的数据
                _cacheBytesLength -= index;
                Array.Copy(_cacheBytes, index, _cacheBytes, 0, _cacheBytesLength);

                break;
            }
        }
    }
}

测试

​ 启动服务器后，运行 Unity，服务器中可以定时收到心跳消息：

image-20250504093828255

​ 结束运行 Unity，等待 5s 后，可看到服务器显示断开连接：

image-20250504095602541
Unity——心跳消息
m0_51743362的博客
06-01 2206
心跳消息 在长连接中，客户端和服务端之间定期发送的一种特殊的数据包 用于通知对方自己还在线，以确保长连接的有效性 由于其发送的时间间隔往往是固定的持续的，就像是心跳一样一直存在 所以我们称之为心跳消息心跳消息的作用 1.避免非正常关闭客户端时，服务器无法正常收到关闭连接消息 通过心跳消息我们可以自定义超时判断，如果超时没有收到客户端消息，证明客户端已经 断开连接 2.避免客户端长期不发生消息，防火
Unity-网络开发（二）
liuyingbo.com
06-12 2647
网络游戏是以C/S模型为基础进行开发的由客户端和服务端组成弱联网游戏：这种游戏不会频繁的进行数据通信，客户端和服务端之间每次连接只处理一次请求，服务端处理完客户端的请求后返回数据后就断开连接了强联网游戏：这种游戏会频繁的和服务端进行通信，会一直和服务端保持连接状态，不停的和服务器之间交换数据通过之前的知识我们知道，网络游戏是以C/S模型为基础进行开发的由客户端和服务端组成弱联网游戏代表：一般的三消类休闲游戏、卡牌游戏等都会是弱联网游戏，这些游戏的核心玩法都由客户端完成，客户端处理完成后只是告诉服务端一个结果
Unity3D网络游戏实战——深入了解TCP，解决暗藏问题
白小飞
11-04 2131
前言 这一章基本属于科普章节，相信看到这篇文章的人也学习过计算机网络，所以很多基础知识，比如三握四挥这些就不多说了。 5.3常用TCP参数 5.3.1ReceiveBufferSize 指定了操作系统读缓冲区的大小，默认值8192。缓冲区满了，发送端会暂停发送数据，较大的缓冲区可以减少发送短暂停的概率，提高效率。 5.3.2SendBufferSize 指定操作系统写缓冲区的大小，默认值也是8192，设定的大一点也比较好~ 5.3.3NoDelay 默认情况TCP会使用Nagle算法发送数据，因为TCP/I
【Unity】 在Unity中实现Tcp通讯（4）———心跳机制
NOBE
06-09 3035
前几篇内容，分别阐述了Unity中实现Tcp通讯的客户端、服务端的实现以及引入ProtoBuf进行数据序列化的方式。 这篇来写一下心跳机制。 在第二篇内容中，对于客户端是否断开连接，是通过判断接受到的数据流是否是空来判断连接是否断开。 代码是这样的： int length = m_Socket.EndReceive(ir); if(length < 1) { IPEndPoint endPoint = m_Socket.RemoteEndPoint as IPEndPoint;.
Unity网络模块开发
Danny
10-11 1002
网络的本质是让我们可以通过物理设备传递2进制数据，让设备和设备之间可以通信协议的字面意思：经过谈判、协商而制定的共同承认、共同遵守的文件网络协议的基本概念：网络协议是计算机网络中进行数据交换而建立的规则、标准或约定的集合指的是计算机网络中互相通信的对等实体之间交换信息时所必须遵守的规则的集合OSI模型是网络通信的基本规则OSI模型是国际组织定义的一套理论基础，主要用于网络通信的规则TCP/IP协议是基于OSI模型的工业实现TCP/IP协议是基于这套理论基础真正实现的通信规则。
Unity3D网络游戏实战——通用客户端模块
白小飞
11-07 1055
前言 书中说的是搭建一套商业级的客户端网络模块，一次搭建长期使用。 本章主要是完善大乱斗游戏中的网络模块，解决粘包分包、完整发送数据、心跳机制、事件分发等功能 6.1网络模块设计 核心是静态类NetManager，它对外提供了一系列方法 NetManager.Connect(ip,port)连接服务端 NetManager.Close() NetManager.Send(msgMove)发送消息，参数为协议对象，NetManager会自动把它转换成二进制数据 NetManager.Update()需外部调
Unity网络——断线重连
明哲的博客
09-24 3637
断线重连应用场景及实现原理 在火车或打电话切应用等网络不好情况下,出现游戏中途掉线重连的问题.此时进行断线重连避免了重新进入登录界面等过程.
Unity3D网络通讯（四）--Socket通讯之Tcp通讯
Vaccae的博客
09-17 906
学更好的别人，做更好的自己。——《微卡智享》本文长度为2650字，预计阅读8分钟前言UnityWebRequest通过Restful的通讯我们已经实现了，《笔记|Unity异步处理与UI...
Unity3D网络游戏实战——通用服务器框架
白小飞
11-09 1万+
前言 网络游戏涉及客户端和服务端。服务端程序记录玩家数据，处理客户端发来的协议。本文就介绍一套通用客户端的实现。 该框架基于Select多路复用处理网络消息，具有粘包半包处理、心跳机制等功能，还是用MySQL数据库存储玩家数据，是一套功能较完备的C#服务端程序。一般单个服务端进程可以承载数百名玩家，如果更多就需要改为分布式架构。 7.1服务端架构 服务端两大核心是处理客户端的消息和存储玩家数据。 客户端与服务端通过TCP连接，使两者可以传递数据，服务端还连接着MySQL数据库，可将玩家数据保存到数据库中。
Unity基础知识汇总
热门推荐
levosam的博客
05-12 1万+
2.Unity相关知识2.1 Unity介绍Unity成为一款可以轻松创建游戏和三维互动的开发工具，是一个专业跨平台游戏引擎Unity操作快捷键 Ctrl   N New Scene 新建场景 Ctrl   O Open Scene 打开场景 Ctrl   S Save Scene 保存 Ctrl Shift S Save Scene as 保存场景为 Ctrl Shif...
protobuf网络通信机制.rar
09-14
6. **错误处理**：在TCP通信中，需要考虑网络中断、数据丢失等情况，因此需要实现适当的错误检测和恢复机制，例如超时重传、心跳包等。 7. **性能优化**：考虑到网络延迟对游戏体验的影响，可能需要对数据包大小、...
美团后端开发一面
最新发布
weixin_54385104的博客
05-06 388
内存中；单线程多路复用；数据结构优秀，举了sds和跳表例子；
Nginx核心功能——nginx代理
2401_88768957的博客
05-01 1359
主要作用是将客户端的请求转发给目标服务器，并将响应返回给客户端Nginx 的 正向代理 充当客户端的“中间人”，它赋予开发者精准控制URL的能力，让请求的流转不再受限于物理路径，而是通过逻辑规则灵活适配业务需求。Nginx的七层(应用层)反向代理基于HTTP/HTTPS 协议。Nginx的四层(网络层)反向代理基于 TCP/UDP 协议，改成break标记，使用浏览器请求，
wireshark抓包也能被篡改？
ailx10
05-03 436
本身并不能修改数据包，但是tcprewrite 可以修改数据包，然后通过tcpreplay 进行重放，这个时候wireshark抓的包，就是被篡改后的了。ailx10网络安全优秀回答者互联网行业 安全攻防员去咨询步骤一：安装 libpcap-dev步骤二：下载源代码，并编译安装步骤三：准备pcap包，以访问知乎的pcap包为例，记住篡改前的信息步骤四：跟着ailx10，开干修改pcap包的源IP地址，从192.168.0.108改成1.1.1.1。
网络安全的原理和基本知识点
mrzyun0811的博客
05-05 216
Python在网络安全防护中具有广泛的应用，通过利用丰富的库和模块，可以实现网络扫描、漏洞检测、渗透测试、恶意软件分析、防火墙规则管理、Web安全防护、安全日志分析和加密通信等功能，帮助提升网络系统的安全性和抵御潜在威胁的能力。网络安全：保护网络系统和数据免受攻击、损坏或未经授权的访问，确保其机密性、完整性和可用性。使用Python解析和分析系统日志、网络流量日志，检测异常活动，及时发现潜在的安全威胁。使用nmap库进行端口扫描和主机发现，识别网络中的开放端口和服务，发现潜在漏洞。
ActiveMQ 性能优化与网络配置实战（一）
qq_42190530的博客
05-01 1331
NIO 与 BIO 模型选择、协议优化（OpenWire/Stomp）、生产者限流与消费者预取策略。
SD - WAN 跨境网络专线部署方式介绍
seaarea_818的博客
04-30 399
以某企业为例，其在欧洲的分支机构只需将 CPE 设备接入现有的网络环境，通过简单的配置，就能快速与国内总部的网络建立安全、稳定的连接。管理员坐在总部的办公室里，通过控制器的管理界面，就能清晰地了解到欧洲分支网络的运行状态，包括每条链路的带宽使用情况、网络延迟等信息，并根据实际需求灵活调整网络策略。在部署 SD - WAN 跨境网络专线时，企业通常会在国内总部和欧洲分支机构分别部署 CPE设备，这一设备就像是连接企业网络与外部网络的智能桥梁。部署过程也较为便捷，企业无需进行大规模的网络改造工程。
C++负载均衡远程调用学习之Agent代理模块基础构建
qq_27302885的博客
05-04 983
C++负载均衡远程调用学习之Agent代理模块基础构建
【JavaEE】网络原理之初识（1.0）
mr_yuanshen的博客
04-30 1001
IP地址用于标识主机网络地址。
unity socket 断开连接
02-11
### 处理Unity中Socket断开连接的原因及解决方案 当处理Unity中的Socket断开连接情况时，主要关注点在于确保客户端和服务端能够正确识别并响应断开事件。以下是具体分析： #### 客户端主动断开连接 为了使服务器能及时感知到客户端的断开动作，可以在客户端设计专门的消息机制来通知服务器。这通常涉及向服务器发送特定命令或信号表明即将关闭连接。 ```csharp // Unity C# Client Code Example public void Disconnect() { try { byte[] message = Encoding.UTF8.GetBytes("disconnect"); socket.Send(message); socket.Shutdown(SocketShutdown.Both); socket.Close(); Debug.Log("Client has disconnected from server."); } catch (Exception ex) { Debug.LogError($"Error during disconnect: {ex.Message}"); } } ``` 此代码片段展示了如何构建一个简单的`Disconnect()`函数用于优雅地终止会话[^2]。 #### 服务端检测异常断开 对于未预期的网络中断或其他非正常结束的情形，服务端应具备监控心跳包的能力以判断某个连接是否仍然活跃。一旦发现长时间未能接收到指定客户的心跳，则假定其已掉线，并清理相应资源。 ```javascript // Node.js Server Side Handling Disconnection Logic io.on('connection', function(socket){ console.log('a user connected'); // Heartbeat mechanism to detect unexpected disconnections let heartbeatInterval; const HEARTBEAT_TIMEOUT = 5000; // milliseconds function startHeartbeat() { clearInterval(heartbeatInterval); heartbeatInterval = setInterval(() => { if (!socket.connected) return cleanupResources(); socket.emit('ping'); }, HEARTBEAT_TIMEOUT / 2); setTimeout(() => { if (!socket.connected) cleanupResources(); }, HEARTBEAT_TIMEOUT); } startHeartbeat(); socket.on('pong', () => startHeartbeat()); function cleanupResources(){ clearInterval(heartbeatInterval); io.to(socket.id).emit('disconnected'); console.log(`User ${socket.id} was unexpectedly disconnected.`); } }); ``` 上述脚本实现了基本的心跳监测逻辑以及相应的清理流程[^1]。 #### 连接状态管理 无论何时发生任何类型的断开——无论是计划内的还是意外发生的——都应当更新应用程序内部关于当前活动连接的信息库。这样可以防止残留数据干扰后续操作，并有助于诊断潜在问题。 ```csharp private void OnClose(object sender, EventArgs e) { var client = (TcpClient)sender; lock (_clientsSyncRoot) { _clients.Remove(client.Client.RemoteEndPoint); } Console.WriteLine($"{client.Client.RemoteEndPoint} closed the connection."); } ``` 这段C#代码示范了怎样安全移除不再有效的TCP客户端实例[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

蔗理苦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值