• TCP通讯程序的编写

    目录

    1.TCP和UDP区别

    2.TCP通讯程序的编写流程

    3.实现一次循环通信

    4.改进---多进程方式实现多次通信 

    5.改进---多线程方式实现多次通信 

    6.改进---多线程方式+字典方式实现多次通信 

     

    1.TCP和UDP区别

    TCP：面向连接、可靠传输、面向字节流  应用场景：文件传输（安全性高于实时性）

    UDP：无连接、不可靠、面向数据报  应用场景：视频、音频（实时性高于安全性）

    2.TCP通讯程序的编写流程

    服务器端：

    1. 创建套接字
    2. 为套接字绑定地址信息
    3. 开始监听---将套接字状态置为LISTEN 告诉系统这个套接字可以开始处理连接，tcp服务器会为每个客户端创建一个新的套接字用于与指定客户端通信
    4. 获取新建连接socket的套接字描述符
    5. 收发数据
    6. 关闭套接字

    客户端：

    1. 创建套接字
    2. 绑定地址信息（不推荐客户端主动绑定地址信息）
    3. 向服务器发起数据
    4. 收发数据
    5. 关闭套接字

    3.实现一次循环通信

    代码如下：

    tcp_socket.hpp:

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8.  
    9. #define MAX_LISTEN 5
    10. #define CHECK_RES(q) if((q)==false) { return -1;}
    11. class TcpSocket{
    12.    private:
    13.        int _sockfd;
    14.    public:
    15.        TcpSocket():_sockfd(-1){}
    16.     //创建套接字  
    17.      bool Socket()
    18.        {
    19.          _sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    20.          if(_sockfd < 0)
    21.          {
    22.            perror("socket error");
    23.            return false;
    24.          }
    25.        return true;
    26.        }
    27.  
    28.    //绑定地址信息
    29.        bool Bind(const std::string &ip,uint16_t port)
    30.        {
    31.          struct sockaddr_in addr;//先定义一个ipv4的地址结构
    32.          addr.sin_family = AF_INET;
    33.          addr.sin_port = htons(port);
    34.          addr.sin_addr.s_addr = inet_addr(ip.c_str());
    35.          socklen_t len = sizeof(struct sockaddr_in);
    36.          int ret = bind(_sockfd,(struct sockaddr*)&addr,len);
    37.          if(ret<0)
    38.          {
    39.             perror("bind error");
    40.             return false;
    41.          }
    42.          return true;
    43.          }
    44.  
    45.     //向服务器发起连接
    46.       bool Connect(const std::string &ip,uint16_t port)
    47.      {
    48.         struct sockaddr_in addr;
    49.        addr.sin_family = AF_INET;
    50.        addr.sin_port = htons(port);
    51.        addr.sin_addr.s_addr = inet_addr(ip.c_str());
    52.        socklen_t len = sizeof(struct sockaddr_in);
    53.        int ret = connect(_sockfd,(struct sockaddr*)&addr,len);
    54.        if(ret < 0)
    55.          {
    56.            perror("connect error");
    57.            return false;
    58.          }
    59.        return true;
    60.      }
    61.      
    62.    //服务器开始监听
    63.     bool Listen(int backlog = MAX_LISTEN)
    64.      {
    65.       int ret = listen(_sockfd,backlog);
    66.       if(ret < 0)
    67.       {
    68.         perror("listen error");
    69.         return false;
    70.       }
    71.      return true;
    72.     }
    73.  
    74.   //获取新建连接
    75.     bool Accept(TcpSocket *sock,std::string *ip=NULL,uint16_t *port=NULL)
    76.     {
    77.      struct sockaddr_in addr;
    78.      socklen_t len = sizeof(struct sockaddr_in);
    79.      int newfd = accept(_sockfd,(struct sockaddr*)&addr,&len);
    80.      if(newfd<0)
    81.        {
    82.         perror("accept error");
    83.         return false;
    84.        }
    85.      sock->_sockfd = newfd;
    86.      if(ip != NULL)
    87.       {
    88.         *ip = inet_ntoa(addr.sin_addr);
    89.       }
    90.      if(port != NULL)
    91.       {
    92.         *port = ntohs(addr.sin_port);
    93.       }
    94.      return true;
    95.     }
    96.  
    97.    //接受数据
    98.   bool Recv(std::string *body)
    99.   {
    100.    char tmp[4096] = {0};
    101.    int ret = recv(_sockfd,tmp,4096,0);
    102.    if(ret < 0)
    103.    {
    104.     perror("recv error");
    105.     return false;
    106.    }
    107.    else if(ret == 0)
    108.    {
    109.     std::cout<<"peer shutdown!\n";
    110.     return false;
    111.    }
    112.    body->assign(tmp,ret);//从tmp中截取ret长度大小的数据
    113.    return true;
    114.  }
    115.  
    116.  
    117.  
    118.    //发送数据
    119.     bool Send(const std::string &body)
    120.     {
    121.        int ret;
    122.        ret = send(_sockfd,body.c_str(),body.size(),0);
    123.        if(ret < 0)
    124.        {
    125.          perror("send error");
    126.          return false;
    127.        }
    128.      return true;
    129.     }
    130.  
    131.   //关闭套接字
    132.   bool Close()
    133.   {
    134.     if(_sockfd!= -1)
    135.     {
    136.       close(_sockfd);
    137.     }
    138.    return true;
    139.   }
    140.   
    141.  
    142.  
    143.  
    144. };

    tcp_srv.cpp:

    1. #include "tcp_socket.hpp"
    2. int main()
    3. {
    4.   TcpSocket lst_sock;
    5.  
    6.   //创建套接字
    7.    CHECK_RES(lst_sock.Socket());
    8.   //绑定地址信息
    9.    CHECK_RES(lst_sock.Bind("192.168.164.128",20000));
    10.   //开始监听
    11.    CHECK_RES(lst_sock.Listen());
    12.    while(1)
    13.    {
    14.     //获取新建连接
    15.      TcpSocket conn_sock;
    16.      std::string cliip;
    17.      uint16_t cliport;
    18.      bool ret = lst_sock.Accept(&conn_sock,&cliip,&cliport);
    19.      if(ret < 0)
    20.      {
    21.       continue;
    22.      }
    23.     std::cout<<"new connect:"<":"<
    24.      //使用新建连接与客户端通信
    25.      std::string buf;
    26.      ret = conn_sock.Recv(&buf);
    27.      if(ret == false)
    28.      {
    29.       conn_sock.Close();
    30.       continue;
    31.      }
    32.       std::cout<<"client say:"<
    33.       std::cout<<"server say:";
    34.       fflush(stdout);
    35.       std::cin>>buf;
    36.       ret = conn_sock.Send(buf);
    37.       if(ret == false)
    38.       {
    39.        conn_sock.Close();
    40.        continue;
    41.       }
    42.      }
    43.    
    44.    // 关闭套接字
    45.    lst_sock.Close();
    46.    return 0;
    47.   }

    tcp_cli.cpp:

    1. #include "tcp_socket.hpp"
    2.  
    3. int main(int argc,char* argv[])
    4. {
    5.   if(argc!= 3)
    6.   {
    7.     std::cout<<"please input server address!\n";
    8.     std::cout<<"USsage:./tcp_cli 192.168.164.128 20000\n";
    9.     return -1;
    10.   }
    11.  std::string srv_ip = argv[1];
    12.  uint16_t srv_port = std::stoi(argv[2]);
    13.  TcpSocket cli_sock;
    14.  //创建套接字
    15.    CHECK_RES(cli_sock.Socket());
    16.  //绑定地址信息（客户端不推荐）
    17.  //向服务器发起连接
    18.    CHECK_RES(cli_sock.Connect(srv_ip,srv_port));
    19.    while(1)
    20.    {
    21.      //与服务器通信
    22.      std::string buf;
    23.      std::cout<<"client say:";
    24.      fflush(stdout);
    25.      std::cin>>buf;
    26.      bool ret = cli_sock.Send(buf);
    27.     if(ret == false)
    28.     {
    29.      cli_sock.Close();
    30.      return -1;
    31.     }
    32.     buf.clear();
    33.     ret = cli_sock.Recv(&buf);
    34.     if(ret == false)
    35.     {
    36.      cli_sock.Close();
    37.      return -1;
    38.     }
    39.     std::cout<<"server say:"<
    40.   }
    41.  //关闭套接字
    42.   cli_sock.Close();
    43.   return 0;
    44.  }

    makefile:

    1. all:tcp_srv tcp_cli
    2. tcp_cli:tcp_cli.cpp
    3. 	g++ -std=c++11 $^ -o $@
    4. tcp_srv:tcp_srv.cpp
    5. 	g++ -std=c++11 $^ -o $@

    测试结果如下：

    先运行服务器端程序：

     再运行客户端程序：

     客户端发送数据：

    服务器端收到客户端发送的数据并进行回复：

    客户端收到了服务器端的回复：

     

    4.改进---多进程方式实现多次通信 

     服务器端代码改动 （cp tcp_srv.cpp process_srv.cpp)：

    process_srv.cpp代码如下：

    1. #include "tcp_socket.hpp"
    2. #include
    3.  
    4. int new_worker(TcpSocket &conn_sock)
    5. {
    6.  pid_t pid = fork();
    7.   if(pid < 0)
    8.   {
    9.     perror("fork error");
    10.     return -1;
    11.   }
    12.   else if(pid == 0)
    13.   {
    14.     while(1)
    15.     {
    16.       std::string buf;
    17.       bool ret = conn_sock.Recv(&buf);
    18.       if(ret == false)
    19.       {
    20.         conn_sock.Close();
    21.         break;
    22.       }
    23.       std::cout<<"client say:"<
    24.       std::cout<<"server say:";
    25.       fflush(stdout);
    26.       std::cin>>buf;
    27.       ret = conn_sock.Send(buf);
    28.       if(ret == false)
    29.       {
    30.         conn_sock.Close();
    31.         break;
    32.       }
    33.     }
    34.    conn_sock.Close();
    35.    exit(-1);
    36.   }
    37. return 0;
    38. }
    39.  
    40.  
    41.  
    42. int main()
    43. {
    44.  
    45.  //显示忽略子进程退出信号，相当于告诉系统，子进程退出直接释放资源
    46.   signal(SIGCHLD,SIG_IGN); 
    47.  
    48.  TcpSocket lst_sock;
    49.  
    50.   //创建套接字
    51.    CHECK_RES(lst_sock.Socket());
    52.   //绑定地址信息
    53.    CHECK_RES(lst_sock.Bind("192.168.164.128",20000));
    54.   //开始监听
    55.    CHECK_RES(lst_sock.Listen());
    56.    while(1)
    57.    {
    58.     //获取新建连接
    59.      TcpSocket conn_sock;
    60.      std::string cliip;
    61.      uint16_t cliport;
    62.      bool ret = lst_sock.Accept(&conn_sock,&cliip,&cliport);
    63.      if(ret < 0)
    64.      {
    65.       continue;
    66.      }
    67.     std::cout<<"new connect:"<":"<
    68.      //使用新建连接与客户端通信
    69.     new_worker(conn_sock);
    70.     //父进程必须关闭套接字，否则连接的客户端越多，创建的套接字越多
    71.     //但父进程本质并不与客户端通信，所以最后会资源耗尽
    72.     //因此必须关闭，而父子进程数据独有，因此父进程的关闭并不影响子进程
    73.     conn_sock.Close();
    74.  
    75.     } 
    76.      // 关闭套接字
    77.    lst_sock.Close();
    78.    return 0;
    79.   }

    makefile改动：

    1. all:tcp_srv tcp_cli process_srv
    2. process_srv:process_srv.cpp
    3. 	g++ -std=c++11 $^ -o $@
    4. tcp_cli:tcp_cli.cpp
    5. 	g++ -std=c++11 $^ -o $@
    6. tcp_srv:tcp_srv.cpp
    7. 	g++ -std=c++11 $^ -o $@

    测试结果（可实现多次通信）：

     当前存在的问题：

    若客户端1和客户端2都向服务器发送了数据，服务器在客户端1发送了数据之后并没有回复，在2发了之后才回复，此时回复的是客户端1。

    测试结果如下（1向服务器发送tianyijingheile,2向服务器发送ganjinxiakeba,服务器端二者都可收到，回复xiake是回复给了客户端1）：

    客户端1：

    客户端2：

     服务器端：

    5.改进---多线程方式实现多次通信 

     cp tcp_srv.cpp thread_srv.cpp

    thread_srv.cpp:

    1. #include "tcp_socket.hpp"
    2. #include
    3.  
    4. void* entry(void* arg)
    5. {
    6.  TcpSocket *conn_sock = (TcpSocket*)arg;
    7.    while(1)
    8.   {  
    9.      std::string buf;
    10.      bool ret = conn_sock->Recv(&buf);
    11.      if(ret == false)
    12.      {
    13.       conn_sock->Close();
    14.       break;
    15.      }
    16.       std::cout<<"client say:"<
    17.       std::cout<<"server say:";
    18.       fflush(stdout);
    19.       std::cin>>buf;
    20.       ret = conn_sock->Send(buf);
    21.       if(ret == false)
    22.       {
    23.        conn_sock->Close();
    24.        break;
    25.       }
    26.     }
    27.   conn_sock->Close();
    28.   delete conn_sock;
    29.   return NULL;
    30. }
    31. bool new_worker(TcpSocket *conn_sock)
    32. {
    33.   pthread_t tid;
    34.   int ret = pthread_create(&tid,NULL,entry,(void*)conn_sock);
    35.   if(ret != 0)
    36.   {
    37.       std::cout<<"thread create error\n";
    38.       return false;
    39.   }
    40.   pthread_detach(tid);
    41.   return true;
    42.  }
    43.  
    44. int main()
    45. {
    46.   TcpSocket lst_sock;
    47.  
    48.   //创建套接字
    49.    CHECK_RES(lst_sock.Socket());
    50.   //绑定地址信息
    51.    CHECK_RES(lst_sock.Bind("192.168.164.128",20000));
    52.   //开始监听
    53.    CHECK_RES(lst_sock.Listen());
    54.    while(1)
    55.    {
    56.     //获取新建连接,在堆上申请
    57.      TcpSocket *conn_sock = new TcpSocket();
    58.      std::string cliip;
    59.      uint16_t cliport;
    60.      bool ret = lst_sock.Accept(conn_sock,&cliip,&cliport);
    61.      if(ret < 0)
    62.      {
    63.       continue;
    64.      }
    65.     std::cout<<"new connect:"<":"<
    66.      //使用新建连接与客户端通信
    67.      new_worker(conn_sock);
    68.       
    69.     }
    70.    
    71.    // 关闭套接字
    72.    lst_sock.Close();
    73.    return 0;
    74.   }

    makefile:

    1. all:tcp_srv tcp_cli process_srv thread_srv
    2. thread_srv:thread_srv.cpp
    3. 	g++ -std=c++11 $^ -o $@ -lpthread
    4. process_srv:process_srv.cpp
    5. 	g++ -std=c++11 $^ -o $@
    6. tcp_cli:tcp_cli.cpp
    7. 	g++ -std=c++11 $^ -o $@
    8. tcp_srv:tcp_srv.cpp
    9. 	g++ -std=c++11 $^ -o $@

    测试结果和多进程方式一样，存在的问题也相同。

    6.改进---多线程方式+字典方式实现多次通信 

    cp thread_srv.cpp robot_srv.cpp

    robot_srv.cpp:

    1. #include "tcp_socket.hpp"
    2.  
    3. #include
    4. #include
    5.  
    6. std::unordered_map_dictionaries={
    7.   {"nihao","你好"},
    8.   {"leihou","雷猴"},
    9.   {"hello","hi"}
    10.  };
    11.  
    12.  std::string get_rsp(const std::string &key)
    13. { 
    14.   auto it = _dictionaries.find(key);
    15.   if(it!= _dictionaries.end())
    16.   {
    17.     return it->second;
    18.   }
    19.   return "不要乱说话";
    20. }
    21.  
    22. void* entry(void* arg)
    23. {
    24.  TcpSocket *conn_sock = (TcpSocket*)arg;
    25.    while(1)
    26.   {  
    27.      std::string buf;
    28.      bool ret = conn_sock->Recv(&buf);
    29.      if(ret == false)
    30.      {
    31.       conn_sock->Close();
    32.       break;
    33.      }
    34.     std::string data = get_rsp(buf);  
    35.     ret = conn_sock->Send(data);
    36.       if(ret == false)
    37.       {
    38.        conn_sock->Close();
    39.        break;
    40.       }
    41.     }
    42.   conn_sock->Close();
    43.   delete conn_sock;
    44.   return NULL;
    45. }
    46. bool new_worker(TcpSocket *conn_sock)
    47. {
    48.   pthread_t tid;
    49.   int ret = pthread_create(&tid,NULL,entry,(void*)conn_sock);
    50.   if(ret != 0)
    51.   {
    52.       std::cout<<"thread create error\n";
    53.       return false;
    54.   }
    55.   pthread_detach(tid);
    56.   return true;
    57.  }
    58.  
    59. int main()
    60. {
    61.   TcpSocket lst_sock;
    62.  
    63.   //创建套接字
    64.    CHECK_RES(lst_sock.Socket());
    65.   //绑定地址信息
    66.    CHECK_RES(lst_sock.Bind("192.168.164.128",20000));
    67.   //开始监听
    68.    CHECK_RES(lst_sock.Listen());
    69.    while(1)
    70.    {
    71.     //获取新建连接,在堆上申请
    72.      TcpSocket *conn_sock = new TcpSocket();
    73.      std::string cliip;
    74.      uint16_t cliport;
    75.      bool ret = lst_sock.Accept(conn_sock,&cliip,&cliport);
    76.      if(ret < 0)
    77.      {
    78.       continue;
    79.      }
    80.     std::cout<<"new connect:"<":"<
    81.      //使用新建连接与客户端通信
    82.      new_worker(conn_sock);
    83.       
    84.     }
    85.    
    86.    // 关闭套接字
    87.    lst_sock.Close();
    88.    return 0;
    89.   }

    makefile:

    1. all:tcp_srv tcp_cli process_srv thread_srv robot_srv
    2. robot_srv:robot_srv.cpp
    3. 	g++ -std=c++11 $^ -o $@ -lpthread
    4. thread_srv:thread_srv.cpp
    5. 	g++ -std=c++11 $^ -o $@ -lpthread
    6. process_srv:process_srv.cpp
    7. 	g++ -std=c++11 $^ -o $@
    8. tcp_cli:tcp_cli.cpp
    9. 	g++ -std=c++11 $^ -o $@
    10. tcp_srv:tcp_srv.cpp
    11. 	g++ -std=c++11 $^ -o $@

    测试结果 客户端：

     

  • 相关阅读:
    Java的CompletableFuture，Java的多线程开发
    Qt 框架 6.6版本添加响应式布局,并兼容AArch64 架构
    Elasticsearch高级检索之使用单个字母数字进行分词N-gram tokenizer（不区分大小写）【实战篇】
    一览8个 NFT 分析平台
    MySQL8.0.26安装配置教程(windows 64位)
    ROS-API函数介绍
    第八篇 基于JSP 技术的网上购书系统——商品信息查看、我的购物车、结算中心功能实现（网上商城、仿淘宝、当当、亚马逊）
    y137.第八章 Servless和Knative从入门到精通 -- Serverless概念和基础(一)
    工具： MarkDown学习
    harbor 搭建和部署
  • 原文地址：https://blog.csdn.net/weixin_46153828/article/details/126475480