TCP通讯心跳包通用设计

原因：因为客户端拔网线，断电等，服务器无法判断客户端是否还在线，所以需要心跳包进行判断

（以下图为网络上的，具体是哪个作者忘记了，设计思路从他这里来的）

设计：心跳检测步骤：

1：客户端每隔一段时间，发送一个心跳包给服务器

2：服务端：开启一个定时器，定时将map<id, count>中的count++，如果此时收到心跳包，则将count值设置0

3：收到客户端的心跳包，自动重置计数器

**************************************************************************************************************

以下实现了一个类，可以供客户端，服务器端都使用，双向

heart.h

/*********************************************************************************
*Author:zhouFuLiang
*Date: 2023-03-21  10:45
*Description: 心跳包线程类 每次隔开指定的时间进行一次心跳发送 收到回复即清零 未收到即+1 如此
* 设定指定的时间触发一次，指定的时间次数即可判断是否断开连接
**********************************************************************************/
#ifndef HEARTBEATTHREAD_H
#define HEARTBEATTHREAD_H

#define  HEART_TIME     3               //心跳次数
#define  TIMER_OUT_T    1500            //timer设置的时常

#include <QObject>
#include <QThread>
#include <QMap>
#include <QTimer>

enum HEART_TYPE{
    Heart_NULL = 0,
    Heart_Server,
    Heart_Client,
};

class HeartbeatThread : public QObject
{
    Q_OBJECT
public:
    HeartbeatThread();
    ~HeartbeatThread();
    /*
     * @brief 设置当前心跳包为何种心跳（服务端创建即Heart_Server 客户端创建即Heart_Client）
     * @param hType 心跳包类型
     * @param
     * @return
    */
    void setHeartType(HEART_TYPE hType);
    /*
     * @brief 初始化心跳包计数器容器 全部置0
     * @param
     * @param
     * @return
    */
    void initHeartCounter();
signals:
    //心跳包断掉(服务器收到指定客户端断掉)
    void heartbeatBrokenSer(int nPtr);
    //心跳包断掉（客户端自己断掉了）
    void heartbeatBrokenClient();

    //服务器发送心跳包
    void sendServHeartbeatPackage();
    //客户端发送心跳包
    void sendClientHeartbeatPackage();

private:
    void init();
    void connectPart();

public slots:
    /*
     * @brief 当客户端连接时，将插入一个计数器，对应ptr
     * @param ptr客户端唯一标识
     * @param
     * @return
    */
    void onInsertCounterChanged(int nPtr);
    /*
     * @brief 将计数器置零(针对如果是客户端时)
     * @param
     * @param
     * @return
    */
    void onResetCounter();


private slots:
    void threadStartRun();
    void threadStopRun();
    void destoryResource();

    void onTimerout();

private:
    QThread *m_pThread;
    HEART_TYPE m_heartType;
    QMap<int, int> m_mapCounter;       //计数器列表（server）
    int m_nCounter;                    //计数器（client）
    QTimer *m_pTimer;
};

#endif // HEARTBEATTHREAD_H

heart.cpp

#include "heartbeatthread.h"
#include <QDebug>
#include <QApplication>

HeartbeatThread::HeartbeatThread(): m_heartType(Heart_NULL)
  ,m_nCounter(0),m_pTimer(nullptr),m_pThread(nullptr)
{
    init();
    connectPart();
}

HeartbeatThread::~HeartbeatThread()
{
    if(m_pTimer->isActive()){
        m_pTimer->stop();
    }
    m_pTimer->deleteLater();
    m_pTimer = nullptr;
}

void HeartbeatThread::init()
{
    m_pThread = new QThread;
    m_pTimer = new QTimer;
    m_pTimer->setInterval(TIMER_OUT_T);    //1.5秒启动一次
    m_pTimer->moveToThread(m_pThread);
    moveToThread(m_pThread);
    m_pThread->start();
}

void HeartbeatThread::connectPart()
{
    connect(qApp, &QApplication::aboutToQuit, this, &HeartbeatThread::destoryResource, Qt::DirectConnection);
    connect(m_pThread, &QThread::started, this, &HeartbeatThread::threadStartRun, Qt::DirectConnection);
    connect(m_pThread, &QThread::finished, this, &HeartbeatThread::threadStopRun, Qt::DirectConnection);
    connect(m_pTimer, &QTimer::timeout, this, &HeartbeatThread::onTimerout);
}


void HeartbeatThread::setHeartType(HEART_TYPE hType)
{
    m_heartType = hType;
}

void HeartbeatThread::initHeartCounter()
{
    if(Heart_Server == m_heartType){        //服务端心跳计数器容器进行初始化
        QList<int> nKeyList = m_mapCounter.keys();
        for(int i=0;i<nKeyList.size();i++){
            m_mapCounter[nKeyList.at(i)] = 0;
        }
    }else if(Heart_Client == m_heartType){  //客户端心跳计数器初始化
        m_nCounter = 0;
    }
}

void HeartbeatThread::onInsertCounterChanged(int nPtr)
{
    if(!m_mapCounter.contains(nPtr))
        m_mapCounter.insert(nPtr, 0);
    else
        m_mapCounter[nPtr] = 0;
}

void HeartbeatThread::onResetCounter()
{
    m_nCounter = 0;
}


void HeartbeatThread::threadStartRun()
{
    qDebug() << "HeartbeatThread thread start running, thread ID: " << QThread::currentThreadId();
    m_pTimer->start();
}

void HeartbeatThread::threadStopRun()
{
    if(m_pTimer->isActive()){
        qDebug() << "delete timer...";
        m_pTimer->stop();
    }
    m_pTimer->deleteLater();
    m_pTimer = nullptr;
    qDebug() << "HeartbeatThread thread has exited, thread ID: " << QThread::currentThreadId();
}

void HeartbeatThread::destoryResource()
{
    m_pThread->quit();
    m_pThread->wait();
}

void HeartbeatThread::onTimerout()
{
    if(Heart_Server == m_heartType){
        QList<int> nKeyList = m_mapCounter.keys();
        for(int i=0;i<nKeyList.size();i++){
            ++m_mapCounter[nKeyList.at(i)];
            if(m_mapCounter[nKeyList.at(i)] > HEART_TIME){     //超过3次，进行推送断掉
                emit heartbeatBrokenSer(nKeyList.at(i));
                m_mapCounter.remove(nKeyList.at(i));        //删除数据
            }
            emit sendServHeartbeatPackage();
        }
    }else if(Heart_Client == m_heartType){
        m_nCounter++;
        if(m_nCounter > HEART_TIME){
            emit heartbeatBrokenClient();                   //超过3次，进行推送断掉
        }
        emit sendClientHeartbeatPackage();
    }else{
        qDebug() << "hearbeat is null...";
    }
}

main.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <heartbeatthread.h>
namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
signals:
    void insertCounter(int ptr);

private slots:
    void on_pushButton_clicked();
    void onHeartbeatBrokenSer(int nPtr);
    void onServHeartbeatPackage();

private:
    Ui::MainWindow *ui;
    HeartbeatThread *m_pHeart;
};

#endif // MAINWINDOW_H

main.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDebug>

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    qDebug() << "MainWindow Thread, thread ID: " << QThread::currentThreadId();
    m_pHeart = new HeartbeatThread;

    connect(this, &MainWindow::insertCounter, m_pHeart, &HeartbeatThread::onInsertCounterChanged);
    connect(m_pHeart, &HeartbeatThread::heartbeatBrokenSer, this, &MainWindow::onHeartbeatBrokenSer);
    connect(m_pHeart, &HeartbeatThread::sendServHeartbeatPackage, this, &MainWindow::onServHeartbeatPackage);
    
    
    for(int i = 0; i < 5; i++){
        emit insertCounter(i);
    }

    m_pHeart->setHeartType(Heart_Server);

}

MainWindow::~MainWindow()
{
    delete ui;
    m_pHeart->deleteLater();
    m_pHeart = NULL;
}

void MainWindow::on_pushButton_clicked()
{

}

void MainWindow::onHeartbeatBrokenSer(int nPtr)
{
    qDebug() << "Client ptr is " << nPtr << " dis link";
}

void MainWindow::onServHeartbeatPackage()
{
    emit insertCounter(2);
}