TCP socket心跳包示例程序

最新推荐文章于 2023-11-19 13:16:29 发布
最新推荐文章于 2023-11-19 13:16:29 发布
阅读量339 收藏
点赞数
分类专栏： Linux基础知识 网络编程 文章标签： tcp/ip 网络协议 网络
原文链接：https://blog.csdn.net/xqhrs232/article/details/54137544?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0.pc_relevant_default&spm=1001.2101.3001.4242.1&utm_relevant_index=3
版权

TCP socket心跳包示例程序_xqhrs232的专栏-CSDN博客_setsockopt 心跳包

原文地址::TCP socket心跳包示例程序_神奕的专栏-CSDN博客_tcp心跳包

相关文章

1、Linux网络编程--服务端判断客户端断开的经验方法 ----Linux网络编程--服务端判断客户端断开的经验方法_志存高远-CSDN博客_info.tcpi_state

2、Socket心跳包机制及SO_KEEPALIVE套接口选项----Socket心跳包机制及SO_KEEPALIVE套接口选项_u012252959的博客-CSDN博客

3、TCP Keepalive HOWTO----TCP Keepalive HOWTO

在做游戏开发时，经常需要在应用层实现自己的心跳机制，即定时发送一个自定义的结构体（心跳包），让对方知道自己还活着，以确保连接的有效性。

在TCP socket心跳机制中，心跳包可以由服务器发送给客户端，也可以由客户端发送给服务器，不过比较起来，前者开销可能更大。—— 这里实现的是由客户端给服务器发送心跳包，基本思路是：

1） 服务器为每个客户端保存了IP和计数器count，即map<fd, pair<ip, count>>。服务端主线程采用 select 实现多路IO复用，监听新连接以及接受数据包（心跳包），子线程用于检测心跳：

  • 如果主线程接收到的是心跳包，将该客户端对应的计数器 count 清零；
  • 在子线程中，每隔3秒遍历一次所有客户端的计数器 count： 
    • 若 count 小于 5，将 count 计数器加 1；
    • 若 count 等于 5，说明已经15秒未收到该用户心跳包，判定该用户已经掉线；

2） 客户端则只是开辟子线程，定时给服务器发送心跳包（本示例中定时时间为3秒）。


下面是Linux下一个socket心跳包的简单实现：

/*************************************************************************
    > File Name: Server.cpp
    > Author: SongLee
    > E-mail: lisong.shine@qq.com
    > Created Time: 2016年05月05日 星期四 22时50分23秒
    > Personal Blog: http://songlee24.github.io/
 ************************************************************************/
#include<netinet/in.h>   // sockaddr_in
#include<sys/types.h>    // socket
#include<sys/socket.h>   // socket
#include<arpa/inet.h>
#include<unistd.h>
#include<sys/select.h>   // select
#include<sys/ioctl.h>
#include<sys/time.h>
#include<iostream>
#include<vector>
#include<map>
#include<string>
#include<cstdlib>
#include<cstdio>
#include<cstring>
using namespace std;
#define BUFFER_SIZE 1024
 
enum Type {HEART, OTHER};
 
struct PACKET_HEAD
{
    Type type;
    int length;
};
 
void* heart_handler(void* arg);
 
class Server
{
private:
    struct sockaddr_in server_addr;
    socklen_t server_addr_len;
    int listen_fd;    // 监听的fd
    int max_fd;       // 最大的fd
    fd_set master_set;   // 所有fd集合，包括监听fd和客户端fd   
    fd_set working_set;  // 工作集合
    struct timeval timeout;
    map<int, pair<string, int> > mmap;   // 记录连接的客户端fd--><ip, count>
public:
    Server(int port);
    ~Server();
    void Bind();
    void Listen(int queue_len = 20);
    void Accept();
    void Run();
    void Recv(int nums);
    friend void* heart_handler(void* arg);
};
 
Server::Server(int port)
{
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    server_addr.sin_port = htons(port);
    // create socket to listen
    listen_fd = socket(PF_INET, SOCK_STREAM, 0);
    if(listen_fd < 0)
    {
        cout << "Create Socket Failed!";
        exit(1);
    }
    int opt = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
}
 
Server::~Server()
{
    for(int fd=0; fd<=max_fd; ++fd)
    {
        if(FD_ISSET(fd, &master_set))
        {
            close(fd);
        }
    }
}
 
void Server::Bind()
{
    if(-1 == (bind(listen_fd, (struct sockaddr*)&server_addr, sizeof(server_addr))))
    {
        cout << "Server Bind Failed!";
        exit(1);
    }
    cout << "Bind Successfully.\n"; 
}
 
void Server::Listen(int queue_len)
{
    if(-1 == listen(listen_fd, queue_len))
    {
        cout << "Server Listen Failed!";
        exit(1);
    }
    cout << "Listen Successfully.\n";
}
 
void Server::Accept()
{
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
 
    int new_fd = accept(listen_fd, (struct sockaddr*)&client_addr, &client_addr_len);
    if(new_fd < 0)
    {
        cout << "Server Accept Failed!";
        exit(1);
    }
 
    string ip(inet_ntoa(client_addr.sin_addr));    // 获取客户端IP
 
    cout << ip << " new connection was accepted.\n";
 
    mmap.insert(make_pair(new_fd, make_pair(ip, 0)));
 
    // 将新建立的连接的fd加入master_set
    FD_SET(new_fd, &master_set);
    if(new_fd > max_fd)
    {
        max_fd = new_fd;
    }
}   
 
void Server::Recv(int nums)
{
    for(int fd=0; fd<=max_fd; ++fd)
    {
        if(FD_ISSET(fd, &working_set))
        {
            bool close_conn = false;  // 标记当前连接是否断开了
 
            PACKET_HEAD head;
            recv(fd, &head, sizeof(head), 0);   // 先接受包头
 
            if(head.type == HEART)
            {
                mmap[fd].second = 0;        // 每次收到心跳包，count置0
                cout << "Received heart-beat from client.\n";
            }
            else
            {
                // 数据包，通过head.length确认数据包长度 
            }   
 
            if(close_conn)  // 当前这个连接有问题，关闭它
            {
                close(fd);
                FD_CLR(fd, &master_set);
                if(fd == max_fd)  // 需要更新max_fd;
                {
                    while(FD_ISSET(max_fd, &master_set) == false)
                        --max_fd;
                }
            }
        }
    }   
}
 
void Server::Run()
{
    pthread_t id;     // 创建心跳检测线程
    int ret = pthread_create(&id, NULL, heart_handler, (void*)this);
    if(ret != 0)
    {
        cout << "Can not create heart-beat checking thread.\n";
    }
 
    max_fd = listen_fd;   // 初始化max_fd
    FD_ZERO(&master_set);
    FD_SET(listen_fd, &master_set);  // 添加监听fd
 
    while(1)
    {
        FD_ZERO(&working_set);
        memcpy(&working_set, &master_set, sizeof(master_set));
 
        timeout.tv_sec = 30;
        timeout.tv_usec = 0;
 
        int nums = select(max_fd+1, &working_set, NULL, NULL, &timeout);
        if(nums < 0)
        {
            cout << "select() error!";
            exit(1);
        }
 
        if(nums == 0)
        {
            //cout << "select() is timeout!";
            continue;
        }
 
        if(FD_ISSET(listen_fd, &working_set))
            Accept();   // 有新的客户端请求
        else
            Recv(nums); // 接收客户端的消息
    }
}
 
 
// thread function
void* heart_handler(void* arg)
{
    cout << "The heartbeat checking thread started.\n";
    Server* s = (Server*)arg;
    while(1)
    {
        map<int, pair<string, int> >::iterator it = s->mmap.begin();
        for( ; it!=s->mmap.end(); )
        {   
            if(it->second.second == 5)   // 3s*5没有收到心跳包，判定客户端掉线
            {
                cout << "The client " << it->second.first << " has be offline.\n";
 
                int fd = it->first;
                close(fd);            // 关闭该连接
                FD_CLR(fd, &s->master_set);
                if(fd == s->max_fd)      // 需要更新max_fd;
                {
                    while(FD_ISSET(s->max_fd, &s->master_set) == false)
                        s->max_fd--;
                }
 
                s->mmap.erase(it++);  // 从map中移除该记录
            }
            else if(it->second.second < 5 && it->second.second >= 0)
            {
                it->second.second += 1;
                ++it;
            }
            else
            {
                ++it;
            }
        }
        sleep(3);   // 定时三秒
    }
}
 
int main()
{
    Server server(15000);
    server.Bind();
    server.Listen();
    server.Run();
    return 0;
}

/*************************************************************************
    > File Name: Client.cpp
    > Author: SongLee
    > E-mail: lisong.shine@qq.com
    > Created Time: 2016年05月05日 星期四 23时41分56秒
    > Personal Blog: http://songlee24.github.io/
 ************************************************************************/
#include<netinet/in.h>   // sockaddr_in
#include<sys/types.h>    // socket
#include<sys/socket.h>   // socket
#include<arpa/inet.h>
#include<sys/ioctl.h>
#include<unistd.h>
#include<iostream>
#include<string>
#include<cstdlib>
#include<cstdio>
#include<cstring>
using namespace std;
#define BUFFER_SIZE 1024
 
enum Type {HEART, OTHER};
 
struct PACKET_HEAD
{
    Type type;
    int length;
};
 
void* send_heart(void* arg); 
 
class Client 
{
private:
    struct sockaddr_in server_addr;
    socklen_t server_addr_len;
    int fd;
public:
    Client(string ip, int port);
    ~Client();
    void Connect();
    void Run();
    friend void* send_heart(void* arg); 
};
 
Client::Client(string ip, int port)
{
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    if(inet_pton(AF_INET, ip.c_str(), &server_addr.sin_addr) == 0)
    {
        cout << "Server IP Address Error!";
        exit(1);
    }
    server_addr.sin_port = htons(port);
    server_addr_len = sizeof(server_addr);
    // create socket
    fd = socket(AF_INET, SOCK_STREAM, 0);
    if(fd < 0)
    {
        cout << "Create Socket Failed!";
        exit(1);
    }
}
 
Client::~Client()
{
    close(fd);
}
 
void Client::Connect()
{
    cout << "Connecting......" << endl;
    if(connect(fd, (struct sockaddr*)&server_addr, server_addr_len) < 0)
    {
        cout << "Can not Connect to Server IP!";
        exit(1);
    }
    cout << "Connect to Server successfully." << endl;
}
 
void Client::Run()
{
    pthread_t id;
    int ret = pthread_create(&id, NULL, send_heart, (void*)this);
    if(ret != 0)
    {
        cout << "Can not create thread!";
        exit(1);
    }
}
 
// thread function
void* send_heart(void* arg)
{
    cout << "The heartbeat sending thread started.\n";
    Client* c = (Client*)arg;
    int count = 0;  // 测试
    while(1) 
    {
        PACKET_HEAD head;
        head.type = HEART;
        head.length = 0;    
        send(c->fd, &head, sizeof(head), 0);
        sleep(3);     // 定时3秒
 
        ++count;      // 测试：发送15次心跳包就停止发送
        if(count > 15)
            break;
    }
}
 
int main()
{
    Client client("127.0.0.1", 15000);
    client.Connect();
    client.Run();
    while(1)
    {
        string msg;
        getline(cin, msg);
        if(msg == "exit")
            break;
        cout << "msg\n";
    }
    return 0;
}

可以看出，客户端启动以后发送了15次心跳包，然后停止发送心跳包。在经过一段时间后（3s*5），服务器就判断该客户端掉线，并断开了连接。 

qq_37659294
关注
专栏目录
C#心跳包的实现
11-23
一个心跳包，检测用户在线的功能，相当于application的功能
C# 实现 TCP服务端+客户端 带心跳机制.zip
12-31
C# 实现 TCP服务端+客户端 带心跳机制。。。
C# 心跳包（服务端，客户端）
04-27
实操项目中切割下来的一部分，功能完整可实现，希望能帮到大家。
C#TCP服务端+客户端（心跳机制）.zip
10-16
基于VS2017 开发，编译直接运行。 自带客户与服务端心跳包验证。 客户端掉线，服务器自动响应。 所有均为事件与封装完全分享。代码高度简洁。 服务端断线与重启，客户端自动重新连接。 客户端消息异常，快速响应事件。 客户端与服务端，调用DOME完全分离。
c++ tcp socket心跳包示例程序
最新发布
01-09
TCP的心跳包是指在TCP连接...以上是一个简单的TCP socket心跳包示例程序，通过该程序可以实现定时向服务器发送心跳包，从而保持TCP连接的稳定性。在实际应用中，可以根据具体需求对心跳包的内容、发送频率等进行调整。
c++ socket tcp demo
02-08
本示例中的"TCP Demo"提供了C++实现TCP客户端和服务器的简单应用，通过socketserver.cpp和socketclient.cpp两个文件来展示。下面我们将深入探讨TCP协议、C++ Socket API以及这两个文件可能包含的关键知识点。 首先...
C#使用Socket实现心跳的方法示例
08-25
第三，需要在Timer的Elapsed事件中，使用Socket对象发送心跳包。 第四，需要在心跳包发送成功后，更新连接状态，以确保连接保持活跃。 在示例代码中，使用了SocketListener类来监听客户端连接，并在客户端连接成功...
C# Socket心跳包跟图片传输，TCP/IP协议响应Demo供学习之用
07-14
通过本示例，学习者可以了解到如何在实际项目中结合C#的Socket、TCP/IP协议、心跳包机制和图片传输，构建稳定且高效的网络通信程序。注意，实际使用时还需要考虑错误处理、安全性以及性能优化等问题。
Qt使用tcp实现的简单服务端和客户端(带心跳检测)
04-13
Qt使用tcp实现的简单服务端和客户端(带心跳检测)。。很基础的实现，大概适合对Qt tcpsever 不太清楚的人看。。
c#tcp服务器+客户端（心跳）.zip
08-23
c#tcp服务器+客户端（心跳）.zip
QT 5 查看网络状态心跳包
07-30
QT5 实现的查看网络状态，利用ping, 实现类似心跳包的作用
C++ Qt TCP的心跳检测机制，断线重连技术，应用层代码重新实现
十年以上编程经验的干货分享
11-19 4013
TCP本身是有一个保活状态的 keep-alive机制，默认是关闭的，需要单独启动就可以；默认保活时间是2小时，不过这个机制是在协议层，也就是传输层生效的，如果应用层出问题了，就不能及时发现问题；如果想要实现断线重连的操作，这个就不好实现了。 另一种方式，可以在应用层自定义模拟这个心跳检测机制，使用线程或者定时器来定时发心跳包即可实现保活功能，并且能做到断线重连的操作。
QT处理TCP连接心跳包问题（6）
编程大魔王
06-14 1275
QT处理TCP连接心跳包问题
qtcpsocket断开_Qt中，网络连接状态分析及心跳包的使用与实现（点赞）
weixin_31542609的博客
12-23 3309
总第22篇在开发网络通信系统的过程中，有时客户端必须要知道网络的连接状态，而客户端与服务器断开连接的因素有很多。本文将综合分析各种情况，在此基础上介绍心跳包的使用与代码实现。1.不同的网络断开连接情况在常见的C/S结构系统中，网络断开连接状况主要可分为下面六种：客户端网线断开；客户端网络断开；客户端通过Http代理连接服务器，代理机器断开代理；客户端通过Http代理连接服务器，代理机器网络断开；客...
Socket网络编程心跳包介绍
qq_37535749的博客
01-26 1441
跳包之所以叫心跳包是因为：它像心跳一样每隔固定时间发一次，以此来告诉服务器，这个客户端还活着。事实上这是为了保持长连接，至于这个包的内容，是没有什么特别规定的，不过一般都是很小的包，或者只包含包头的一个空包。 在TCP的机制里面，本身是存在有心跳包的机制的，也就是TCP的选项：SO_KEEPALIVE。系统默认是设置的2小时的心跳频率。但是它检查不到机器断电、网线拔出、防火墙这些断线。而且逻辑层处理断线可能也不是那么好处理。一般，如果只是用于保活还是可以的。 心跳包一般来说都是在逻辑层发送空的echo包来实
socket中的短连接与长连接,心跳包示例详解
Yqq__00的专栏
09-23 753
举例： 像WEB网站的http服务一般都用短链接，因为长连接对于服务端来说会耗费一定的资源 数据库的连接用长连接， 如果用短连接频繁的通信会造成socket错误，而且频繁的socket 创建也是对资源的浪费。 单工：打印机 半双工：微信聊天只能一方说话，半双工 全双工：打电话双方都能说话，全双工 在计算机网络中主要采用双工方式，其中： 局域网采用半双工方式，
Qt之TCP心跳包
阿清的随手记
04-13 4503
Qt之TCP心跳包 当Qt作为客户端程序，而服务器需要监控客户端的在线状态时，就需要Qt端发送心跳包。心跳包可以是TCP也可以是UDP，这里介绍TCP心跳包的实现方法。 心跳包通常要单开一个线程，在进程运行的过程中一直执行。 代码示例： .h文件 #ifndef HEARTBEATTHREAD_H #define HEARTBEATTHREAD_H #include <QThread> #include <QCoreApplication> #include <QTimer&
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值