C++ TCP socket心跳包示例程式

阿新 • • 發佈：2019-02-06

在做遊戲開發時，經常需要在應用層實現自己的心跳機制，即定時傳送一個自定義的結構體（心跳包），讓對方知道自己還活著，以確保連線的有效性。

在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:  
[email protected]
    > 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: [email protected]
    > 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），伺服器就判斷該客戶端掉線，並斷開了連線。

C++ TCP socket心跳包示例程式

在做遊戲開發時，經常需要在應用層實現自己的心跳機制，即定時傳送一個自定義的結構體（心跳包），讓對方知道自己還活著，以確保連線的有效性。在TCP socket心跳機制中，心跳包可以由伺服器傳送給客戶端，也可以由客戶端傳送給伺服器，不過比較起來，前者開銷可能更大。—— 這裡實現的是由客戶端給伺服器傳送心跳包，基本

socket中的短連線與長連線,心跳包示例詳解

原文地址：http://blog.csdn.net/fireroll/article/details/9043221 TCP連線簡介當網路通訊時採用TCP協議時，在真正的讀寫操作之前，server與client之間必須建立一個連線，當讀寫操作完成後，雙方不再需要這個連線時它

golang中tcp socket粘包問題和處理

enc pack 獲取人工過程 reader 主動 exit ase 轉自：http://www.01happy.com/golang-tcp-socket-adhere/ 在用golang開發人工客服系統的時候碰到了粘包問題，那麽什麽是粘包呢？例如我們和客戶端約定數據

socket心跳包

CP 一次 bsp 數據 recv soc 檢查設置根據跳包之所以叫心跳包是因為：它像心跳一樣每隔固定時間發一次，以此來告訴服務器，這個客戶端還活著。事實上這是為了保持長連接，至於這個包的內容，是沒有什麽特別規定的，不過一般都是很小的包，或者只包含包頭的一個空包

Socket心跳包機制

socket 一段時間活著一個一段 alc HR 開始可能心跳包的發送，通常有兩種技術方法1：應用層自己實現的心跳包由應用程序自己發送心跳包來檢測連接是否正常，大致的方法是：服務器在一個 Timer事件中定時向客戶端發送一個短小精悍的數據包，然後啟動一個

Linux C++ TCP Socket通信實例

內容 set color 分享 int clas 打開 makefile src 環境：Linux 語言：C++ 通信方式：TCP 　　下面用TCP協議編寫一個簡單的服務器、客戶端，其中服務器端一直監聽本機的6666號端口。如果收到連接請求，將接收請求並接收客戶端發來的消息

簡單的C#TCP協議收發資料示例

參考：http://www.cnblogs.com/jzxx/p/5630516.html 一、原作者的這段話很好，先引用一下： Socket的Send方法，並非大家想象中的從一個埠傳送訊息到另一個埠，它僅僅是拷貝資料到基礎系統的傳送緩衝區，然後由基礎系統將傳送緩衝區的資料到連線的另一埠。值得一說的是，這

C++ TCP socket程式設計中的小陷阱（服務端accept 不阻塞和客戶端connect 重連失敗）

在編寫一個使用C++ socket實現的TCP服務端與客戶端小軟體時接連碰上2個小陷阱，終歸是實踐不足，基本功不紮實。第1個問題：服務端的accept函式沒有阻塞程式執行到accept這裡時直接就跳了過去，根本沒停下來。懷疑過socket

Socket心跳包機制總結

跳包之所以叫心跳包是因為：它像心跳一樣每隔固定時間發一次，以此來告訴伺服器，這個客戶端還活著。事實上這是為了保持長連線，至於這個包的內容，是沒有什麼特別規定的，不過一般都是很小的包，或者只包含包頭的一個空包。在TCP的機制裡面，本身是存在有心跳包的機制的，也就是TCP的選項：SO_KEE

C#高效能大容量SOCKET併發（六）：超時Socket斷開（守護執行緒）和心跳包

守護執行緒在服務端版Socket程式設計需要處理長時間沒有傳送資料的Socket，需要在超時多長時間後斷開連線，我們需要獨立一個執行緒（DaemonThread）來輪詢，在執行斷開時，需要把Socket物件鎖定，並呼叫CloseClientSocket來斷開連線，具體

跨平臺C++伺服器程式開發（4）tcp socket狀態圖（server端）

套接字狀態在上一節中，介紹了檔案描述符的概念，我們可以看到socket套接字與磁碟檔案的讀寫方法很相似，但套接字比普通的檔案描述符多了一種狀態，每個開啟的套接字都對應一種狀態，Windows和Linux都可以使用netstat命令檢視。通過觀察套接字狀態

[Linux] c 語言tcp socket 示例從簡單到複雜

服務端： #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h>

Delphi2010中DataSnap高階技術(5)—建立穩定服務程式之TCP心跳包的使用

為了能讓我們的服務程式更加穩定，有些細節問題必須解決。就如上一講中提到的客戶端拔掉網線，造成伺服器上TCP變成死連線，如果死連線數量過多，對伺服器能長期穩定執行是一個巨大的威脅。另外，經過測試，如果伺服器上有TCP死連線，那麼服務程式連線資料庫，也會產生那個一個死連線。這

Unity3D 遊戲引擎之C#使用Socket與HTTP連接server數據傳輸包

tco 類型 oba connect asp bre amp 客戶 star 近期比較忙。有段時間沒寫博客拉。近期項目中須要使用HTTP與Socket。雨松MOMO把自己這段時間學習的資料整理一下。有關Socket與HTTP的基礎知識MOMO就不贅述拉，不懂得朋友自己

Windows socket c++ TCP UDP 簡單客戶端 vs2013

進行 msg print type pro i/o while write n) socket 主要是網絡中進程之間的通信，起源於Unix，而“一切皆可文件”的思想一樣可以用在socket上，即打開 -> 讀寫 -> 關閉。 int socket(int do

TCP連接探測中的Keepalive和心跳包

代碼結構 article 自帶斷開結構連接防火墻不用內部轉載：http://blog.csdn.net/aa2650/article/details/17027845 1. TCP保活的必要性 1) 很多防火墻等對於空閑socket自動關閉 2) 對於非正常斷

Linux socket編程示例（最簡單的TCP和UDP兩個例子）

步驟 proto 詳解 dto 應該 pro sock bind ram 一、socket編程　　網絡功能是Uinux/Linux的一個重要特點，有著悠久的歷史，因此有一個非常固定的編程套路。　　基於TCP的網絡編程：　　　　基於連接, 在交互過程中, 服務器

Socket之心跳包實現思路

har date 超過 off comm padding int msg tar 由於最近要做一個客戶端，但是要求有一個掉線檢測的功能，下面讓我們看看使用自定義的HeartBeat方式來檢測客戶端的連接情況。心跳包的實現思路：客戶端連接上服務端後，在服務端會維護一個在

（轉）基於C#的socket編程的TCP異步實現

ont .text 相關 llb 對象創建 length ethos dex eof 一、摘要　　本篇博文闡述基於TCP通信協議的異步實現。二、實驗平臺　　Visual Studio 2010 三、異步通信實現原理及常用方法 3.1 建立連接　　　在同步模式中，

TCP保活：心跳包/乒乓包/SO_KEEPALIVE

引言：長連線斷開後一直佔用系統資源，可以通過心跳包判斷連線是否斷開；使用心跳包檢測到連線已經死了，就斷開連線。總的來說，心跳包主要也就是用於長連線的保活和斷線處理。一般的應用下，判定時間在30-40秒比較不錯。如果實在要求高，那就在6-9秒。 TCP保活機

C++ TCP socket心跳包示例程式

相關推薦