Linux下 C++ TCP服务器与客户端一对多通信

于 2019-07-19 08:09:20 发布
阅读量1.3k 收藏 13
点赞数 2
CC 4.0 BY-SA版权
文章标签： linux tcp c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44866066/article/details/96473075
本文介绍了一个基于TCP的心跳机制实现方案，包括服务器端和客户端的代码实现细节。通过使用心跳包来检测连接状态，确保了长连接的有效维持，并且能够及时发现并处理断线情况。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

服务器端

#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;
    char msg[BUFFER_SIZE];
};

void* send_heart(void* arg);
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<int, int> > mmap;   // 记录连接的客户端fd--><ip, count>
public:
    Server(int port);
    ~Server();
    void Bind();
    void Listen(int queue_len = 20);
    void Accept();
    void Run();
    void Recv();
    friend void* heart_handler(void* arg);
    friend void* send_heart(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);
    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));//开启keepalive
}

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 << "绑定成功.\n";
}

void Server::Listen(int queue_len)
{
    if(-1 == listen(listen_fd, queue_len))
    {
        cout << "Server Listen Failed!";
        exit(1);
    }
    cout << "监听成功.\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
    int htons(ntohs(client_addr.sin_port));    // 获取端口号

    cout << htons << " 新的客户端连接成功.\n";

   // cout << ip << " new connection was accepted.\n";
    cout<<new_fd<<endl;

    mmap.insert(make_pair(new_fd, make_pair(htons, 0)));

    // 将新建立的连接的fd加入master_set
    FD_SET(new_fd, &master_set);
    if(new_fd > max_fd)
    {
        max_fd = new_fd;
    }
}

void Server::Recv()
{
    for(int fd=0; fd<=max_fd; ++fd)
    {
        if(FD_ISSET(fd, &working_set))
        {
            bool close_conn = false;  // 标记当前连接是否断开了

            PACKET_HEAD head;
            int num=recv(fd, &head, sizeof(head), 0);   // 先接受包头
            if(num<0)
            {
                cout<<"接收消息出错"<<endl;
                close_conn = true;
            }
            else if(num==0)
            {
                cout<<"客户端"<<mmap[fd].first<<"退出"<<endl;
                close(fd);
                FD_CLR(fd, &master_set);
                //exit(0);
            }
            else{

            if(head.type == HEART)
            {
                mmap[fd].second = 0;        // 每次收到心跳包，count置0
                int s=mmap[fd].first;
                cout << "收到来自客户端"<<s<<" 的心跳消息了\n";
            }
            else if(head.type == OTHER)
            {
                int a=mmap[fd].first;
                cout << "收到来自客户端的 "<<a<<" 的通讯消息::"<<head.msg<<endl;
            }
            }
            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";
    }
    pthread_t id1;
    int ret1 = pthread_create(&id, NULL, send_heart, (void*)this);
    if(ret1 != 0)
    {
        cout << "Can not create thread!";
        exit(1);
    }

    max_fd = listen_fd;   // 初始化max_fd
    FD_ZERO(&master_set);
    FD_SET(listen_fd, &master_set);  // 添加监听fd
    FD_SET(STDIN_FILENO, &master_set);
        if(max_fd <STDIN_FILENO)
        {
            max_fd = STDIN_FILENO;
        }
    char input_msg[BUFFER_SIZE];
    while(1)
    {
         map<int, pair<int, int> >::iterator it = mmap.begin();
        PACKET_HEAD head;
        head.type = OTHER;
        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, NULL);
        if(nums < 0)
        {
            cout << "select() error!";
            exit(1);
        }

        else if(nums == 0)
        {
            continue;
        }

        if(FD_ISSET(STDIN_FILENO, &working_set))
            {

                bzero(head.msg, BUFFER_SIZE);
                fgets(head.msg, BUFFER_SIZE, stdin);
                //输入“quit"则退出服务器
                if(strncmp(head.msg,"exit",4) == 0)
                {
                    cout<<"end"<<endl;
                    exit(0);
                }
                for( ; it!=mmap.end(); )
                {

                    if(it->first!= 0){

                    cout<<"发给客户端:"<<it->first<<endl;
                    cout<<"发送消息:"<<head.msg<<endl;
                    send(it->first, &head, sizeof(head), 0);
                        }
                        it++;
                    }
            }
         else
         {

         if(FD_ISSET(listen_fd, &working_set))
            Accept();   // 有新的客户端请求
        else
             Recv(); // 接收客户端的消息
         }
    }
}


// thread function
void* heart_handler(void* arg)
{
    cout << "服务器端开始接收心跳包.\n";
    Server* s = (Server*)arg;
    while(1)
    {
        map<int, pair<int
        , int> >::iterator it = s->mmap.begin();
        for( ; it!=s->mmap.end(); )
        {
            if(it->second.second == 5)   // 1s*5没有收到心跳包，判定客户端掉线
            {
                cout << "客户端 " << it->second.first << " 掉线了\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(1);   // 定时三秒
    }
}

void* send_heart(void* arg)
{
    cout << "服务器端开始发送心跳包.\n";
    Server* c = (Server*)arg;
    int count = 0;  // 测试
    while(1)
    {
        PACKET_HEAD head;
        head.type = HEART;
        head.msg[BUFFER_SIZE] = 0;
        map<int, pair<int, int> >::iterator it = c->mmap.begin();
        for( ; it!=c->mmap.end(); ){
                if(it->first!=0){
                 cout << "服务器端开始发送心跳包.\n";
                 send(it->first, &head, sizeof(head), 0);
                }
        it++;
        }
        sleep(3);     // 定时3秒

       //++count;      // 测试：发送15次心跳包就停止发送
       // if(count > 3)
         //   break;
    }
}

int main()
{
    Server server(15000);//创建一个socket文件描述符
    server.Bind();//绑定
    server.Listen();//监听
    server.Run();
    return 0;
}

客户端

#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>
#include<map>
using namespace std;
#define BUFFER_SIZE 1024

enum Type {HEART, OTHER};

struct PACKET_HEAD
{
    Type type;
    char msg[BUFFER_SIZE];
};

void* send_heart(void* arg);
void* heart_handler(void* arg);

void* send_messages(void* arg);
class Client
{
public:
    struct sockaddr_in server_addr;
    socklen_t server_addr_len;
    int fd;
    int max_fd;       // 最大的fd
    fd_set client_fd_set;
    fd_set working_set;  // 工作集合
    struct timeval tv;
    struct timeval timeout;
    static int time;
     map<int, pair<int, int> > mmap;   // 记录连接的客户端fd--><ip, count>
public:
    Client(string ip, int port);
    ~Client();
    void Connect();
    void Run();
    void Recv();
    friend void* send_heart(void* arg);
    friend void* heart_handler(void* arg);
    friend void* send_messages(void* arg);
};
int Client::time=0;
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()
{
    max_fd = fd;   // 初始化max_fd
    FD_ZERO(&client_fd_set);
    FD_SET(fd, &client_fd_set);  // 添加监听fd
    FD_SET(STDIN_FILENO, &client_fd_set);
        if(max_fd <STDIN_FILENO)
        {
            max_fd = STDIN_FILENO;
        }
    pthread_t id;
    int ret = pthread_create(&id, NULL, send_heart, (void*)this);
    if(ret != 0)
    {
        cout << "Can not create thread!";
        exit(1);
    }

    pthread_t id1;     // 创建心跳检测线程
    int ret1 = pthread_create(&id1, NULL, heart_handler, (void*)this);
    if(ret1 != 0)
    {
        cout << "Can not create heart-beat checking thread.\n";
    }
    pthread_t id2;     // 创建心跳检测线程
    int ret2 = pthread_create(&id1, NULL, send_messages, (void*)this);
    if(ret2 != 0)
    {
        cout << "Can not create heart-beat checking thread.\n";
    }

    while(1)
    {
        Recv(); // 接收客户端的消息
}
}

void* heart_handler(void* arg)
{
    cout << "客户端开始接收心跳包.\n";
    Client* s = (Client*)arg;
    while(1)
    {
            if(s->time == 5)   // 1s*5没有收到心跳包，判定客户端掉线
            {
                cout << "服务器端掉线了\n";

                close(s->fd);            // 关闭该连接
                FD_CLR(s->fd, &s->client_fd_set);
                exit(0);

            }
            else if(s->time < 5 && s->time >= 0)
            {
                s->time += 1;
            }
         sleep(1);   // 定时三秒
        }

    }



// thread function
void* send_heart(void* arg)
{
    cout << "客户端开始发送心跳包.\n";
    Client* c = (Client*)arg;
    //int count = 0;  // 测试
    while(1)
    {
        PACKET_HEAD head;
        head.type = HEART;
        head.msg[BUFFER_SIZE] = 0;
        send(c->fd, &head, sizeof(head), 0);
        sleep(3);     // 定时3秒

     // ++count;      // 测试：发送15次心跳包就停止发送
        //if(count > 3)
          //  break;
    }
}

void Client::Recv()
{

            PACKET_HEAD head;

            int num=recv(fd, &head, sizeof(head), 0);   // 先接受包头
            if(num<0)
            {
                cout<<"接收消息出错"<<endl;
            }
            else if(num==0)
            {
                cout<<"服务器端退出"<<endl;
                close(fd);
                FD_CLR(fd, &client_fd_set);
                exit(0);
            }
            else{

            if(head.type == HEART)
            {
                time= 0;        // 每次收到心跳包，count置0
                cout << "收到来自服务器端的心跳消息了\n";
            }
            else if(head.type == OTHER)
            {

                cout << "收到来自服务器端的的通讯消息:"<<head.msg<<endl;
            }
            }

        }

void* send_messages(void* arg)
{
    Client* c = (Client*)arg;
    while(1)
        {
        PACKET_HEAD head;
        head.type=OTHER;
        FD_ZERO(&c->working_set);
        memcpy(&c->working_set, &c->client_fd_set, sizeof(c->client_fd_set));
        if(FD_ISSET(STDIN_FILENO, &c->working_set))
        {

         bzero(head.msg, BUFFER_SIZE);
         //fgets(head.msg, BUFFER_SIZE, stdin);
         cin>>head.msg;
        if(strncmp(head.msg,"exit",4) == 0)
        {
           cout<<"end"<<endl;
            exit(0);
        }
        if(send(c->fd, &head, sizeof(head), 0) == -1)
        {
            perror("发送消息出错!\n");
        }
        }

        }
}
int main()
{
    Client client("127.0.0.1", 15000);
    client.Connect();
    client.Run();

    return 0;
}

很多注释代码是测试用的 不用管

vevemom
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值