TCP心跳检测机制（异常处理）

最新推荐文章于 2024-07-30 08:15:00 发布
最新推荐文章于 2024-07-30 08:15:00 发布
阅读量1.9k 收藏 10
点赞数 2
文章标签： tcp/ip 服务器 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65072319/article/details/132733484
版权
为什么需要心跳检测

当通过TCP建立连接的服务端A与客户端B，客户端B突然异常退出，比如断网、断电、程序异常终止等等，服务端A无法知道客户端B的非正常断开，可能仍然保持着与客户端的连接状态，仍会等待接收来自客户端B的消息，这会占用服务器资源（如内存），尤其是在有大量客户端连接的情况下，造成资源浪费。

这是因为TCP建立连接都是通过发送数据实现的，即三次握手和四次挥手，当客户端异常退出时，是无法发送数据给服务端，无法通知服务端断开连接，导致服务端误以为仍与客户端保持健康连接。

因此需要心跳检测来监测连接状态。心跳检测允许服务器或另一端的应用程序定期检查客户端的存活状态。如果客户端不再响应心跳包，服务器可以采取适当的措施，如关闭连接、释放资源或通知其他相关方。

什么是心跳检测

心跳检测通常通过发送心跳包（也称为心跳消息或保持活动消息）来实现。这是一种小型的数据包或消息，它在连接上定期发送，用于验证连接的存活状态。

客户端发起心跳：客户端每隔一段时间发送心跳包，如果客户端在设定时间没有收到服务端返回的应答消息，经重试机制后，客户端认为服务器异常，断开与服务器的连接。

服务器发起心跳：服务器设置超时机制，主动向客户端发送心跳包，客户端未在规定时间内返回应答包导致超时，服务器将认为客户端异常，关闭与客户端的连接。

心跳检测步骤
  1. 服务器设置超时机制，服务器每隔一个时间间隔发送一个心跳包给服务器客户端
  2. 客户端接收到检测包，应该回应一个应答包给服务器端
  3. 如果服务器端收到客户端的应答包，则说明客户端正常，重置超时倒计时
  4. 在一定时间内未收到来自客户端的应答包，则说明客户端断开了连接
心跳包分类

1、应用层自己实现的心跳包

服务器设置超时机制，向客户端发送一个心跳包，然后启动一个低级别的线程，在该线程中不断检测客户端的回应，一段时间内未收到回应，则判定客户端掉线，同时在客户端来说，一定时间内收不到来自服务器的心跳包，则认为服务器异常，也将主动断开连接。这种方式将会在服务器端使用两个线程维护一个客户端，当客户端数量增多时，会成倍增加资源消耗，增大服务器负载。

另一种方式可以在心跳包中增加标志位，以区分该消息为心跳包还是正常消息交流，在心跳包发送频率较低的情况下将不会影响正常的消息交流，同时无需额外增加一个线程来维护心跳检测

2、TCP的保活机制KeepAlive

考虑到一个服务器会连接多个客户端，因此在应用层自己实现心跳包，代码较多且复杂。TCP协议层内置了KeepAlive功能来实现心跳功能，且发送的是数据长度为零的零心跳包。

服务端或是客户端，一方开启KeepAlive功能后，将会自动在规定时间内向对方发送心跳包， 而另一方在收到心跳包后就会自动回复，以告诉对方仍正常连接在线。

然而开启KeepAlive功能将会牺牲额外的宽带和流量，因此TCP协议层默认关闭了KeepAlive功 能。此外，如果超时时间设置的过短，将会因为短暂的网络波动而断开健康的TCP连接。

实例

实际上，当客户端或是服务器异常退出时，另一端的接收函数会出现两种情况，一种recv将会因为连接被破坏一直收到最后一次消息相同内容，另一种情况则是连接被破坏后，被检测出，recv将会返回错误值，-1或0。

通过返回值，可以很好的判断出连接异常，但是当返回值无法判断时，则需要引入心跳检测。以下示例中，服务器与客户端设置超时机制，服务器在规定时间内接收不到来自客户端的消息，将会判断为客户端异常而断开连接，而在客户端中，则是启用了两个线程，一个专门接收来自服务器的消息，再心跳检测时，一定时间内接收不到应答包将会判断为服务器异常，从而断开连接，另一个则是向服务器发送心跳包，来重置服务器的超时时间。当客户端发送心跳包给服务器后，服务器也将返回一个应答包给客户端，以表明服务器仍正常连接。

以下代码的主要核心如图所示：

//Server.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <signal.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <sys/time.h>

int acceptSocket = 0;

struct Message
{
    int flag;
    char content[1024];
};
struct TcpServer
{
    int sock;
};

struct StdThread
{
    pthread_t threadID;
};

//维护客户端线程
void* thread_handle(void* arg)
{
    //acceptSock
    int sock = *(int*)arg;
    struct timeval timeout;
    timeout.tv_sec = 10;  // 设置超时时间为5秒
    timeout.tv_usec = 0;
    setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));

    while (1)
    {
        struct Message m;
        int recv_value;
        recv_value = recv(sock, &m, sizeof(struct Message), 0);
        printf("%d\n", recv_value);

        if (recv_value == -1 || recv_value == 0)
        {
            printf("客户端异常退出！\n");
            return NULL;
        }
        if (m.flag == 1)
        {
            if (send(sock, &m, sizeof(struct Message), 0) < 0)
            {
                perror("TcpServerSend send");
                return NULL;
            }
            printf("heart check!\n");
        }
        else
            printf("content from client: %s\n", m.content);
    }
}

int main()
{
    struct TcpServer* s = (struct TcpServer*)malloc(sizeof(struct TcpServer));
    if (s == NULL)
    {
        printf("InitTcpServer error!\n");
        free(s);
        return -1;
    }
    s->sock = socket(AF_INET, SOCK_STREAM, 0);
    if (s->sock < 0)
    {
        perror("InitTcpServer sock");
        free(s);
        return -1;
    }

    int isUse = 1;
    //允许端口和地址复用
    if (setsockopt(s->sock, SOL_SOCKET, SO_REUSEADDR, &isUse, 4) != 0)
    {
        perror("InitTcpServer setsockopt");
        free(s);
        return -1;
    }

    struct sockaddr_in addr;
    //协议族
    addr.sin_family = AF_INET;
    //端口号
    addr.sin_port = htons(8199);
    //IP地址
    addr.sin_addr.s_addr = inet_addr("192.168.254.133");

    if (bind(s->sock, (struct sockaddr*)&addr, sizeof(addr)) != 0)
    {
        perror("InitTcpServer bind");
        free(s);
        return -1;
    }
    if (listen(s->sock, 10) < 0)
    {
        perror("InitTcpServer listen");
        free(s);
        return -1;
    }

    while (1)
    {
        //等待客户端接入
        struct sockaddr_in ClientAddr;
        socklen_t len = 1;
        int acceptSock = accept(s->sock, (struct sockaddr*)&ClientAddr, &len);
        if (acceptSock < 0)
        {
            perror("TcpServerAccept accept");
            free(s);
            return -1;
        }
        struct StdThread* t = (struct StdThread*)malloc(sizeof(struct StdThread));
        if (t == NULL)
        {
            printf("InitThread malloc error!\n");
            free(s);
            return -1;
        }
        if (pthread_create(&t->threadID, NULL, thread_handle, &acceptSock) != 0)
        {
            printf("InitThread pthread_create error!\n");
            free(s);
            return -1;
        }
        if (pthread_detach(t->threadID) != 0)
        {
            printf("DetchThread error!\n");
        }
    }
    return 0;
}
//Client.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <signal.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <sys/time.h>

struct Message
{
    int flag;
    char content[1024];
};

struct TcpClient
{
    int sock;
};

struct StdThread
{
    pthread_t threadID;
};

//创建接收服务器消息线程
void* thread_handle(void* arg)
{
    struct TcpClient* c_temp = (struct TcpClient*)arg;
    struct timeval timeout;
    timeout.tv_sec = 5;  // 设置超时时间为5秒
    timeout.tv_usec = 0;
    setsockopt(c_temp->sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
    while (1)
    {
        struct Message message;
        int recv_value;
        recv_value = recv(c_temp->sock, &message, sizeof(struct Message), 0);
        printf("%d\n", recv_value);
        if (recv_value == -1 || recv_value == 0)
        {
            printf("服务器异常退出！\n");
            exit(0);
        }
        if (message.flag == 1)
        {
            printf("heart check!\n");
        }
        else
            printf("Message Content: %s\n", message.content);
    }
}

//心跳检测线程
void* thread_heart(void* arg)
{
    struct TcpClient* c_temp = (struct TcpClient*)arg;
    struct Message temp_msg;
    temp_msg.flag = 1;
    while (1)
    {
        if (send(c_temp->sock, &temp_msg, sizeof(temp_msg), 0) < 0)
        {
            perror("TcpServerSend send");
            exit(0);
        }
        sleep(3);
    }
}

int main()
{
    struct TcpClient* c = (struct TcpClient*)malloc(sizeof(struct TcpClient));
    if (c == NULL)
    {
        printf("InitTcpClient error!\n");
        free(c);
        return -1;
    }
    c->sock = socket(AF_INET, SOCK_STREAM, 0);
    if (c->sock < 0)
    {
        perror("InitTcpClient sock");
        free(c);
        return -1;
    }
    struct sockaddr_in addr;
    //协议族
    addr.sin_family = AF_INET;
    //端口号
    addr.sin_port = htons(8199);
    //IP地址
    addr.sin_addr.s_addr = inet_addr("192.168.254.133");

    if (connect(c->sock, (struct sockaddr*)&addr, sizeof(addr)) != 0)
    {
        perror("InitTcpClient connect");
    }

    //创建接收服务器消息线程
    struct StdThread* t = (struct StdThread*)malloc(sizeof(struct StdThread));
    if (t == NULL)
    {
        printf("InitThread malloc error!\n");
        free(c);
        return -1;
    }
    if (pthread_create(&t->threadID, NULL, thread_handle, c) != 0)
    {
        printf("InitThread pthread_create error!\n");
        free(c);
        return -1;
    }

    if (pthread_detach(t->threadID) != 0)
    {
        printf("DetchThread error!\n");
    }

    //创建心跳检测线程
    struct StdThread* t_heart = (struct StdThread*)malloc(sizeof(struct StdThread));
    if (t_heart == NULL)
    {
        printf("InitThread malloc error!\n");
        free(c);
        free(t);
        return -1;
    }
    if (pthread_create(&t_heart->threadID, NULL, thread_heart, c) != 0)
    {
        printf("InitThread pthread_create error!\n");
        free(t);
        free(c);
        return -1;
    }

    if (pthread_detach(t_heart->threadID) != 0)
    {
        printf("DetchThread error!\n");
    }

    struct Message m;

    while (1)
    {
        printf("please input your message :");
        scanf("%s", m.content);
        while (getchar() != '\n');
        if (send(c->sock, &m, sizeof(m), 0) < 0)
        {
            perror("TcpServerSend send");
            return -1;
        }
    }

    return 0;
}

啾两口
关注
java tcp 心跳机制_关于TCP长连接和发送心跳的一些理解
weixin_34359680的博客
02-16 880
原因TCP是一种有连接的协议，但是这个连接并不是指有一条实际的电路，而是一种虚拟的电路。TCP的建立连接和断开连接都是通过发送数据实现的，也就是我们常说的三次握手、四次挥手。TCP两端保存了一种数据的状态，就代表这种连接，TCP两端之间的路由设备只是将数据转发到目的地，并不知道这些数据实际代表了什么含义，也并没有在其中保存任何的状态信息，也就是说中间的路由设备没有什么连接的概念，只是将数据转发到目...
Rabbitmq heartbea心跳检测机制原理解析
01-08
其基本原理是检测对应的socket连接上数据的收发是否正常，如果一段时间内没有收发数据，则向对端发送一个心跳检测包，如果一段时间内没有回应则认为心跳超时，即认为对端可能异常crash了。 rabbitmq也不例外，heat
TCP socket通信实例（心跳）
10-18
一个简单的SOCKET 通信实例，加入了心跳信息。实用 。
TCP接口心跳包学习笔记
ssz__的博客
06-21 814
即时通讯：虚拟机模拟服务器，可以暂停运行的代码，Xshell当客户端访问服务器（telnet 192.168.56.103 9001），进入聊天室。此时暂停服务器，模拟服务器掉线，客户端ping不同，在没有心跳机制的情况下，服务端掉线，对方不可知，客户端不能发消息，网络不可知。例子：一个接口网线、CPU、电线、网卡都正常，但是此时这个接口已经死循环，无法处理请求，此种情况检查不出来。设想：如果客户端掉线，服务端不知道，此时还维持链接，就是额外无效系统开销。2.TCP 》》》长链接 （后面转成TCP）
TCP/IP协议——心跳机制详解
最新发布
qq_3517289697的博客
07-30 614
心跳包之所以叫心跳包是因为：它像心跳一样每隔固定时间发一次，以此来告诉服务器，这个客户端还活着。事实上这是为了保持长连接，至于这个包的内容，是没有什么特别规定的，不过一般都是很小的包，或者只包含包头的一个空包。
心跳机制讲解及实例
一个新人博客，愿多多支持。
06-18 1375
心跳机制出现在tcp长连接中，客户端和服务器之见定时发送一种特殊的数据包通知对方还在线，以确保tcp链接地可靠性，有可能tcp链接由于某些原因(列入网线被拔了，突然断电)导致客户端断了，但是服务器不知道客户端断了，服务器还保持与客户端连接的状态，所以为了不浪费资源，需要知道客户端非正常中断，服务器把断开客户端断开链接，需要加入心跳包机制。
TCP心跳机制
lfb555的专栏
12-19 5129
所谓的心跳包就是客户端定时放送简单的信息给服务器端，告诉它我还在而已。代码就是每隔几分钟发送一个固定信息给服务器端，服务器端回复一个固定信息。如果服务器端几分钟后没有收到客户端信息则视客户端断开。比如有些通信软件长时间不适用，要想知道它的状态是在线还是离线，就需要心跳包，定时发包收包。     心跳包之所以叫心跳包是因为：它像心跳一样每隔固定时间发一次，以此来告诉服务器，这个客户端还活在。事实上
tcp心跳机制
02-08 1692
<br />對連接上來的連接，進行檢測，以防止客戶端異常關閉，或線路異常斷開，而服務器不知道，得到一個半連接這種情況。<br /><br />當然可以在協議裡加一個心跳包，然後服務器端定時檢測，過一段時間就去輪訓一次，看哪些連接超過多少時間沒有反應。超時就關閉。但這樣有點不爽，要自己寫代碼來完成。還要鎖定連接列表，代價挺大的。<br /><br />記得以前在網上看到可以用 TCP 的 KeepAlive 保活機制來做，但也看到人說沒有效果。我想定TCP協議的那此人，不會定一些無用的功能吧，但MSDN上卻沒
TCP心跳检测
m0_47984232的博客
08-27 9114
TCP心跳检测一.心跳机制2.为什么需要心跳检测3.心跳包发送技术4.两种技术的区别 一.心跳机制 客户端发起心跳：客户端每隔一段时间发送策略消息给Socket服务器，Socket服务器原路返回策略消息，如果客户端在设定时间内没有收到返回的消息，经重试机制后，判定Socket服务器已经down，关闭连接。 服务端发起的心跳：服务端实时记录每条Socket的IO操作时间，每隔一段时间获取所有Socket列表的快照，扫描每条Socket，如果该Socket的IO操作时间距当前时间已超出设定值，则判定客户端Dow
TCP心跳包-定时连接检测
09-22
代码调试成功，适用于Linux环境，可实现服务器与客户端定时交互，判断网络是否掉线，定时间隔可修改客户端itemval相关参数
基于TCP协议的心跳包
09-19
将资料client.c文件的IP地址，修改成虚拟机当前环境下的IP地址即可实现，开发板与虚拟机之间的信息交互
精品软件工具--tcp心跳检测工具库，由客户端库和服务端软件两部分组成。服务端通过心跳端口6969发送心跳请求包，客户.zip
02-17
为了确保数据传输的可靠性，TCP（Transmission Control Protocol）心跳检测机制应运而生，它允许应用程序在连接保持活跃时进行定期检查，及时发现并处理网络问题。本文将深入解析一款名为“精品软件工具”的TCP心跳...
tcp.rar_TCP 心跳_TCP心跳_tcp 心跳_心跳_心跳 TCP
09-19
心跳TCP，也称为TCP心跳检测或TCP Keepalive，是TCP协议的一个可选特性，它允许两个端点周期性地发送“心跳”消息，以确认连接的活跃状态。当一方长时间没有收到对方的数据或心跳响应时，可以判断连接可能已中断，...
基于MFC的TCP心跳检测包
12-01
本话题将围绕“基于MFC的TCP心跳检测包”展开，深入探讨相关知识点。 MFC（Microsoft Foundation Classes）是微软提供的一套C++库，它为Windows应用程序开发提供了丰富的类和函数，简化了Windows API的使用。在MFC...
TCP新手误区--心跳的意义
热门推荐
bjrxyz的专栏
05-01 1万+
TCP新手误区–心跳的意义背景最近面试了很多的学生，发现很多TCP的新手对于TCP的使用有一些误区，而这些坑也是当初我曾经疑惑过得地方。网上很少有文章对这些问题有过详细的解析，即是有也只是直接给出结论和做法，没有人将其中的来龙去脉讲解清楚，所以我将这些问题的来龙去脉在这一系列的文章中讲述出来，希望能让广大TCP的新手避开这些坑。问题我面试时经常会问的一个问题是当TCP两端A、B建立了连接后，如果一端
关于TCP长连接心跳机制
hellmorning的博客
06-14 2359
TCP长连接心跳机制，以及使用C/C++实现
TCP连接与心跳
https://github.com/zm50
07-08 2378
浅聊TCP的连接与心跳, 谈谈自己的看法长连接是为了保持连接的状态, 实现实时数据交互, 心跳是用来检测长连接是否仍然有效, 防止连接断开, 可以及时重连或采取其他措施进行恢复。
Java实现心跳机制详解与代码示例
同时，心跳机制的实现通常需要考虑异常处理和重试策略，以确保在网络不稳定或短暂中断时能正确恢复连接。 总结来说，Java实现心跳机制涉及到对TCP协议的理解、客户端和服务器的协同工作，以及适当的定时任务和状态...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值