• 高级IO---多路转接模型的实现：select模型、poll模型、epoll模型

    目录

     1.select、poll、epoll简介

     2.select

     3.poll

     4.epoll

    1.select、poll、epoll简介

    • select:进行大量的描述符事件监控，返回描述符就绪了的事件集合。
    • poll:针对大量描述符进行监控，但poll的监控是为每个描述符设置了一个事件结构体。
    • epoll的监控是一个异步阻塞监控，监控过程由系统完成，epoll的事件触发方式包含水平触发和边缘触发。

    2.select

    例1：

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6.  
    7. int main()
    8. {
    9.     fd_set rfds;
    10.     FD_ZERO(&rfds);//初始化集合
    11.     while (1)
    12.     {
    13.         struct timeval tv;
    14.         tv.tv_usec = 0;
    15.         tv.tv_sec = 3;
    16.         FD_SET(0,&rfds);//因为select会修改rfds集合，因此每次要重新添加描述符到集合中
    17.         int max_fd = 0;
    18.         //描述符的监控会做一件事情：在返回前，将没有就绪的描述符从集合中移除
    19.         int ret = select(max_fd + 1,&rfds,NULL,NULL,&tv);
    20.         if(ret < 0)
    21.         {
    22.             perror("select error");
    23.             usleep(1000);
    24.             continue;
    25.         }
    26.         else if(ret == 0)
    27.         {
    28.             printf("wait timeout\n");
    29.             usleep(1000);
    30.             continue;
    31.         }
    32.         for(int i = 0;i <= max_fd;i++)//因为没有把所有的描述符保存起来，所以从0到当前最大的描述符逐个判断
    33.         {
    34.             if(FD_ISSET(i,&rfds))//如果i这个描述符在集合中，就表示就绪了事件
    35.             {
    36.                 char buf[1024] = {0};
    37.                 int res = read(i,buf,1023);
    38.                 if(res <= 0)
    39.                 {
    40.                     perror("recv error");
    41.                     FD_CLR(i,&rfds);
    42.                     return -1;
    43.                 }
    44.                 printf("%d 描述符就绪了事件，读取数据:%s\n",i,buf);
    45.             }
    46.         }
    47.             
    48.         
    49.     }
    50.     return 0;
    51. }
    1. select1:select1.c
    2. 	gcc $^ -o $@

    结果如下： 

    例2：

     select.hpp:

    1. #include "tcp_socket.hpp"
    2. #include
    3. #include
    4. #include
    5. class Select
    6. { 
    7.    private:
    8.        fd_set _rfds;//可读事件的描述集合的备份，每次监控都是从这个集合复制一份出来进行监控（select会修改集合）
    9.        int _max_fd;
    10.     public:
    11.        Select():_max_fd(-1)
    12.        {
    13.         //针对成员变量的初始化
    14.         FD_ZERO(&_rfds);
    15.        }
    16.  
    17.        //将sock中的描述符fd,添加到rfds可读事件的描述符集合中
    18.        bool Add(TcpSocket &sock)
    19.        {
    20.             int fd = sock.GetFd();
    21.             FD_SET(fd,&_rfds);//将描述符添加到监控集合中
    22.             _max_fd = _max_fd >fd ?_max_fd:fd;//重新设置最大的描述符
    23.             return true;
    24.        }
    25.  
    26.        //将sock中的描述符fd,从rfds可读事件的描述符集合中移除
    27.        bool Del(TcpSocket &sock)
    28.        {
    29.             int fd = sock.GetFd();
    30.             FD_CLR(fd,&_rfds);//从当前的监控集合中移除指定的描述符
    31.             //如果当前移除的刚好就是最大的描述符，这时候从最大描述符开始向前判断哪个描述符还在集合中，第一个就是最大的
    32.         for(int i = _max_fd;i >= 0;i--)
    33.         {
    34.             if(FD_ISSET(i,&_rfds))
    35.             {
    36.                 _max_fd = i;
    37.                 break;
    38.             }
    39.         }
    40.         return 0;
    41.        }
    42.  
    43.       //开始监控，返回就绪的描述符的数组
    44.        bool Wait(std::vector *arry,int timeout = 3000)
    45.        {
    46.           struct timeval tv;
    47.           tv.tv_sec = timeout / 1000;
    48.           tv.tv_usec = (timeout % 1000) * 1000;
    49.           fd_set tmp = _rfds;//使用临时集合进行监控，因为select会修改监控的集合
    50.           int ret = select(_max_fd +1,&tmp,NULL,NULL,&tv);
    51.           if(ret < 0)
    52.           {
    53.             perror("select error");
    54.             return false;
    55.           }
    56.           else if(ret ==0)
    57.           {
    58.             printf("select timeout!\n");
    59.             return false;
    60.           }
    61.           for(int i=0;i <= _max_fd;i++)
    62.           {
    63.             if(FD_ISSET(i,&tmp))
    64.             {
    65.                 TcpSocket sock;
    66.                 sock.SetFd(i);
    67.                 arry->push_back(sock);
    68.             }
    69.            
    70.           }
    71.           return true;
    72.        }
    73. };

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

    tcp_srv.cpp:

    1. //#include "tcp_socket.hpp"
    2. #include "select.hpp"
    3. int main()
    4. {
    5.   TcpSocket lst_sock;
    6.  
    7.   //创建套接字
    8.    CHECK_RES(lst_sock.Socket());
    9.   //绑定地址信息
    10.    CHECK_RES(lst_sock.Bind("0.0.0.0",20000));
    11.   //开始监听
    12.    CHECK_RES(lst_sock.Listen());
    13.  
    14.    Select s;
    15.    s.Add(lst_sock);//将监听套接字添加到集合中
    16.    while(1)
    17.    {
    18.      std::vector arry;
    19.      bool ret = s.Wait(&arry);
    20.      if(ret == false)
    21.      {
    22.       usleep(1000);
    23.       continue;
    24.      }
    25.      for(TcpSocket &a:arry)
    26.      {
    27.         //array里边就是就绪的描述符，一开始只有一个监听套接字，就绪的肯定就是监听套接字代表有新连接
    28.         if(a.GetFd()==lst_sock.GetFd())//如果就绪的套接字描述符与监听套接字描述符一样，就表示有新建连接
    29.         {
    30.           TcpSocket conn_sock;
    31.           std::string cliip;
    32.           uint16_t cliport;
    33.           bool ret = lst_sock.Accept(&conn_sock,&cliip,&cliport);
    34.           if(ret < 0)
    35.           {
    36.             continue;
    37.           }
    38.           std::cout<<"new connect:"<":"<
    39.           s.Add(conn_sock);//将新建的套接字也添加监控
    40.         }
    41.         else
    42.         {
    43.           std::string buf;
    44.           ret = a.Recv(&buf);
    45.           if(ret == false)
    46.           {
    47.             s.Del(a);//出错了则移除监控
    48.             a.Close();
    49.             continue;
    50.           }
    51.           std::cout<<"client say:"<
    52.  
    53.           std::cout<<"server say:";
    54.           fflush(stdout);
    55.           std::cin>>buf;
    56.           ret = a.Send(buf);
    57.           if(ret == false)
    58.           {
    59.             s.Del(a);
    60.             a.Close();
    61.             continue;
    62.           }
    63.         }
    64.      }
    65.    }
    66.    //关闭套接字
    67.    lst_sock.Close();
    68.    return 0;
    69. }
    70.  
    71.

    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.  }
    45.    
    46.

     makefile:

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

     测试结果：

    服务器端：

     客户端1：

    客户端2：

     服务器处于一直监听的状态，客户端1请求服务器，与服务器连接，可进行多次循环通信，此时客户端2请求建立连接后，也可和服务器进行多次循环通信，注意服务器端绑定的地址以及客户端执行代码输入的地址。

     3.poll

    poll.c:

    1. #include
    2. #include
    3. #include
    4. #include
    5. int main()
    6. {
    7.     struct pollfd pfds[10];
    8.     int poll_count = 0;
    9.     pfds[poll_count].fd = 0;//要监控的描述符是标准输入
    10.     pfds[poll_count].events = POLLIN;//针对标准输入要监控的是可读事件
    11.     poll_count++;
    12.     while(1)
    13.     {
    14.         int ret = poll(pfds,poll_count,3000);
    15.         if(ret < 0)
    16.         {
    17.             perror("poll error");
    18.             usleep(1000);
    19.             continue;
    20.         }
    21.         else if(ret == 0)
    22.         {
    23.             printf("poll timeout!\n");
    24.             usleep(1000);
    25.             continue;
    26.         }
    27.         for(int i=0;i < poll_count;i++)
    28.         {
    29.             if(pfds[i].revents & POLLIN)
    30.             {
    31.                 //pfds[i].fd就绪了可读事件
    32.                 char buf[1024] = {0};
    33.                 read(pfds[i].fd,buf,1023);
    34.                 printf("%d 描述符就绪，读取数据：%s\n",pfds[i].fd,buf);
    35.             }
    36.             else if(pfds[i].revents & POLLOUT)
    37.             {
    38.                 //就绪的是可写事件
    39.             }
    40.         }
    41.  
    42.     }
    43.     return 0;
    44. }

    makefile:

    1. poll:poll.c
    2. 	gcc $^ -o $@

    结果：

     4.epoll

    tcp_socket.hpp:

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9.  
    10.  
    11. #define MAX_LISTEN 5
    12. #define CHECK_RES(q) if((q)==false) { return -1;}
    13. class TcpSocket{
    14.    private:
    15.        int _sockfd;
    16.    public:
    17.        TcpSocket():_sockfd(-1){}
    18.        int GetFd()
    19.        {
    20.         return _sockfd;
    21.        }
    22.        void SetFd(int fd)
    23.        {
    24.         _sockfd = fd;
    25.        }
    26.        void SetNonBlock()
    27.        {
    28.         int flag = fcntl(_sockfd,F_GETFL,0);
    29.         fcntl(_sockfd,F_SETFL,flag | O_NONBLOCK);//在原有属性基础上新增非阻塞属性
    30.        }
    31.     //创建套接字  
    32.      bool Socket()
    33.        {
    34.          _sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    35.          if(_sockfd < 0)
    36.          {
    37.            perror("socket error");
    38.            return false;
    39.          }
    40.        return true;
    41.        }
    42.  
    43.    //绑定地址信息
    44.        bool Bind(const std::string &ip,uint16_t port)
    45.        {
    46.          struct sockaddr_in addr;//先定义一个ipv4的地址结构
    47.          addr.sin_family = AF_INET;
    48.          addr.sin_port = htons(port);
    49.          addr.sin_addr.s_addr = inet_addr(ip.c_str());
    50.          socklen_t len = sizeof(struct sockaddr_in);
    51.          int ret = bind(_sockfd,(struct sockaddr*)&addr,len);
    52.          if(ret<0)
    53.          {
    54.             perror("bind error");
    55.             return false;
    56.          }
    57.          return true;
    58.          }
    59.  
    60.     //向服务器发起连接
    61.       bool Connect(const std::string &ip,uint16_t port)
    62.      {
    63.         struct sockaddr_in addr;
    64.        addr.sin_family = AF_INET;
    65.        addr.sin_port = htons(port);
    66.        addr.sin_addr.s_addr = inet_addr(ip.c_str());
    67.        socklen_t len = sizeof(struct sockaddr_in);
    68.        int ret = connect(_sockfd,(struct sockaddr*)&addr,len);
    69.        if(ret < 0)
    70.          {
    71.            perror("connect error");
    72.            return false;
    73.          }
    74.        return true;
    75.      }
    76.      
    77.    //服务器开始监听
    78.     bool Listen(int backlog = MAX_LISTEN)
    79.      {
    80.       int ret = listen(_sockfd,backlog);
    81.       if(ret < 0)
    82.       {
    83.         perror("listen error");
    84.         return false;
    85.       }
    86.      return true;
    87.     }
    88.  
    89.   //获取新建连接
    90.     bool Accept(TcpSocket *sock,std::string *ip=NULL,uint16_t *port=NULL)
    91.     {
    92.      struct sockaddr_in addr;
    93.      socklen_t len = sizeof(struct sockaddr_in);
    94.      int newfd = accept(_sockfd,(struct sockaddr*)&addr,&len);
    95.      if(newfd<0)
    96.        {
    97.         perror("accept error");
    98.         return false;
    99.        }
    100.      sock->_sockfd = newfd;
    101.      if(ip != NULL)
    102.       {
    103.         *ip = inet_ntoa(addr.sin_addr);
    104.       }
    105.      if(port != NULL)
    106.       {
    107.         *port = ntohs(addr.sin_port);
    108.       }
    109.      return true;
    110.     }
    111.  
    112.   //接收数据
    113.   bool Recv(std::string *body)
    114.   {
    115.    char tmp[4096] = {0};
    116.    int ret = recv(_sockfd,tmp,4096,0);
    117.    if(ret < 0)
    118.    {
    119.     perror("recv error");
    120.     return false;
    121.    }
    122.    else if(ret == 0)
    123.    {
    124.     std::cout<<"peer shutdown!\n";
    125.     return false;
    126.    }
    127.    body->assign(tmp,ret);//从tmp中截取ret长度大小的数据
    128.    return true;
    129.  }
    130.  
    131.    //接受数据
    132.    /*
    133.   bool Recv(std::string *body)
    134.   {
    135.     while(1)
    136.     {
    137.       char tmp[6] = {0};
    138.       int ret = recv(_sockfd,tmp,5,0);
    139.       if(ret < 0)
    140.       {
    141.          if(errno == EAGAIN)//EAGAIN这个错误表示当前缓冲区没有数据了，资源还没有准备好
    142.          {
    143.           return true;
    144.          }
    145.          perror("recv error");
    146.          return false;
    147.       }
    148.       else if(ret == 0)
    149.       {
    150.         std::cout<<"peer shutdown!\n";
    151.         return false;
    152.       }
    153.       *body += tmp;
    154.     }
    155.     return true;
    156.  }
    157.  */
    158.  
    159.    //发送数据
    160.     bool Send(const std::string &body)
    161.     {
    162.        int ret;
    163.        ret = send(_sockfd,body.c_str(),body.size(),0);
    164.        if(ret < 0)
    165.        {
    166.          perror("send error");
    167.          return false;
    168.        }
    169.      return true;
    170.     }
    171.  
    172.   //关闭套接字
    173.   bool Close()
    174.   {
    175.     if(_sockfd!= -1)
    176.     {
    177.       close(_sockfd);
    178.     }
    179.    return true;
    180.   }
    181.   
    182.  
    183.  
    184.  
    185. };

    epoll.hpp:

    1. #include "tcp_socket.hpp"
    2. #include
    3. #include
    4. #include
    5. #include
    6. #define EPOLL_MAX 100
    7. class Epoll
    8. { 
    9.    private:
    10.        int _epfd;//epoll的操作句柄
    11.     public:
    12.        Epoll():_epfd(-1)
    13.        {
    14.             //针对成员变量的初始化
    15.             _epfd = epoll_create(1);
    16.             if(_epfd < 0)
    17.             {
    18.                 perror("epoll error");
    19.                 exit(0);
    20.             }
    21.        }
    22.  
    23.        
    24.        bool Add(TcpSocket &sock)
    25.        {
    26.             struct epoll_event ev;
    27.             ev.events = EPOLLIN;
    28.             ev.data.fd = sock.GetFd();
    29.             int ret = epoll_ctl(_epfd,EPOLL_CTL_ADD,sock.GetFd(),&ev);
    30.             if(ret < 0)
    31.             {
    32.                 perror("epoll_ctl error");
    33.                 return false;
    34.             }
    35.             return true;
    36.        }
    37.  
    38.        
    39.        bool Del(TcpSocket &sock)
    40.        {
    41.             int ret = epoll_ctl(_epfd,EPOLL_CTL_DEL,sock.GetFd(),NULL);
    42.             if(ret < 0)
    43.             {
    44.                 perror("epoll_ctl error");
    45.                 return false;
    46.             }
    47.             return true;
    48.        }
    49.  
    50.       
    51.        bool Wait(std::vector *arry,int timeout = 3000)
    52.        {
    53.           struct epoll_event evs[EPOLL_MAX];
    54.           int ret = epoll_wait(_epfd,evs,EPOLL_MAX,timeout);
    55.           if(ret < 0)
    56.           {
    57.             perror("epoll_wait error");
    58.             return false;
    59.           }
    60.           else if(ret == 0)
    61.           {
    62.             printf("epoll timeout!\n");
    63.             return false;
    64.           }
    65.           for(int i = 0;i < ret;i++)
    66.           {
    67.             if(evs[i].events & EPOLLIN)//目前只管可读事件
    68.             {
    69.                 TcpSocket sock;
    70.                 sock.SetFd(evs[i].data.fd);
    71.                 arry->push_back(sock);
    72.             }
    73.           }
    74.           return true;
    75.        }
    76. };

    tcp_srv.cpp:

    1. /#include "tcp_socket.hpp"
    2. //#include "select.hpp"
    3. #include "epoll.hpp"
    4. int main()
    5. {
    6.   TcpSocket lst_sock;
    7.  
    8.   //创建套接字
    9.    CHECK_RES(lst_sock.Socket());
    10.    //lst_sock.SetNonBlock();
    11.   //绑定地址信息
    12.    CHECK_RES(lst_sock.Bind("0.0.0.0",20000));
    13.   //开始监听
    14.    CHECK_RES(lst_sock.Listen());
    15.  
    16.    //Select s;
    17.    Epoll s;
    18.    s.Add(lst_sock);//将监听套接字添加到集合中
    19.    while(1)
    20.    {
    21.      std::vector arry;
    22.      bool ret = s.Wait(&arry);
    23.      if(ret == false)
    24.      {
    25.       usleep(1000);
    26.       continue;
    27.      }
    28.      for(TcpSocket &a:arry)
    29.      {
    30.         //array里边就是就绪的描述符，一开始只有一个监听套接字，就绪的肯定就是监听套接字代表有新连接
    31.         if(a.GetFd()==lst_sock.GetFd())//如果就绪的套接字描述符与监听套接字描述符一样，就表示有新建连接
    32.         {
    33.           TcpSocket conn_sock;
    34.           std::string cliip;
    35.           uint16_t cliport;
    36.           bool ret = lst_sock.Accept(&conn_sock,&cliip,&cliport);
    37.           if(ret < 0)
    38.           {
    39.             continue;
    40.           }
    41.           std::cout<<"new connect:"<":"<
    42.           //conn_sock.SetNonBlock();
    43.           s.Add(conn_sock);//将新建的套接字也添加监控
    44.         }
    45.         else
    46.         {
    47.           std::string buf;
    48.           ret = a.Recv(&buf);
    49.           if(ret == false)
    50.           {
    51.             s.Del(a);//出错了则移除监控
    52.             a.Close();
    53.             continue;
    54.           }
    55.           std::cout<<"client say:"<
    56.  
    57.           std::cout<<"server say:";
    58.           fflush(stdout);
    59.           std::cin>>buf;
    60.           ret = a.Send(buf);
    61.           if(ret == false)
    62.           {
    63.             s.Del(a);
    64.             a.Close();
    65.             continue;
    66.           }
    67.         }
    68.      }
    69.    }
    70.    //关闭套接字
    71.    lst_sock.Close();
    72.    return 0;
    73. }
    74.

     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.  }
    45.    
    46.

    makefile:

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

    结果： 

     客户端1：

     客户端2：

     修改tcp_socket.hpp如下:

    此时客户端发送helloalaotie,客户端只收到了hello

     以上代码只改动两处：①修改epoll.hpp如下：

    ② 修改tcp_socket.hpp如下：

     则结果为：

     加了EPOLLET的作用：只有在新数据到来时才会触发事件。

    客户端发送nihaoalaotie,服务器只收到nihao,如果不用EPOLLET，则服务器回复客户端后会直接出现缓冲区的剩余数据（eg alaot),如果用了EPOLLET,则只有在客户端发送数据时，才会在缓冲区依次拿数据。---两者都修改了tcp_socket.hpp中的recv函数（如上面所示）。

    修改tcp_socket.hpp如下:  (增加SetNonBlock方法以及Recv方法、增加头文件）

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9.  
    10.  
    11. #define MAX_LISTEN 5
    12. #define CHECK_RES(q) if((q)==false) { return -1;}
    13. class TcpSocket{
    14.    private:
    15.        int _sockfd;
    16.    public:
    17.        TcpSocket():_sockfd(-1){}
    18.        int GetFd()
    19.        {
    20.         return _sockfd;
    21.        }
    22.        void SetFd(int fd)
    23.        {
    24.         _sockfd = fd;
    25.        }
    26.        void SetNonBlock()
    27.        {
    28.         int flag = fcntl(_sockfd,F_GETFL,0);
    29.         fcntl(_sockfd,F_SETFL,flag | O_NONBLOCK);//在原有属性基础上新增非阻塞属性
    30.        }
    31.     //创建套接字  
    32.      bool Socket()
    33.        {
    34.          _sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
    35.          if(_sockfd < 0)
    36.          {
    37.            perror("socket error");
    38.            return false;
    39.          }
    40.        return true;
    41.        }
    42.  
    43.    //绑定地址信息
    44.        bool Bind(const std::string &ip,uint16_t port)
    45.        {
    46.          struct sockaddr_in addr;//先定义一个ipv4的地址结构
    47.          addr.sin_family = AF_INET;
    48.          addr.sin_port = htons(port);
    49.          addr.sin_addr.s_addr = inet_addr(ip.c_str());
    50.          socklen_t len = sizeof(struct sockaddr_in);
    51.          int ret = bind(_sockfd,(struct sockaddr*)&addr,len);
    52.          if(ret<0)
    53.          {
    54.             perror("bind error");
    55.             return false;
    56.          }
    57.          return true;
    58.          }
    59.  
    60.     //向服务器发起连接
    61.       bool Connect(const std::string &ip,uint16_t port)
    62.      {
    63.         struct sockaddr_in addr;
    64.        addr.sin_family = AF_INET;
    65.        addr.sin_port = htons(port);
    66.        addr.sin_addr.s_addr = inet_addr(ip.c_str());
    67.        socklen_t len = sizeof(struct sockaddr_in);
    68.        int ret = connect(_sockfd,(struct sockaddr*)&addr,len);
    69.        if(ret < 0)
    70.          {
    71.            perror("connect error");
    72.            return false;
    73.          }
    74.        return true;
    75.      }
    76.      
    77.    //服务器开始监听
    78.     bool Listen(int backlog = MAX_LISTEN)
    79.      {
    80.       int ret = listen(_sockfd,backlog);
    81.       if(ret < 0)
    82.       {
    83.         perror("listen error");
    84.         return false;
    85.       }
    86.      return true;
    87.     }
    88.  
    89.   //获取新建连接
    90.     bool Accept(TcpSocket *sock,std::string *ip=NULL,uint16_t *port=NULL)
    91.     {
    92.      struct sockaddr_in addr;
    93.      socklen_t len = sizeof(struct sockaddr_in);
    94.      int newfd = accept(_sockfd,(struct sockaddr*)&addr,&len);
    95.      if(newfd<0)
    96.        {
    97.         perror("accept error");
    98.         return false;
    99.        }
    100.      sock->_sockfd = newfd;
    101.      if(ip != NULL)
    102.       {
    103.         *ip = inet_ntoa(addr.sin_addr);
    104.       }
    105.      if(port != NULL)
    106.       {
    107.         *port = ntohs(addr.sin_port);
    108.       }
    109.      return true;
    110.     }
    111.  
    112.   //接收数据
    113.   
    114.   bool RecvCli(std::string *body)
    115.   {
    116.     char tmp[4096] = {0};
    117.     int ret = recv(_sockfd,tmp,4096,0);
    118.     if(ret < 0)
    119.     {
    120.       perror("recv error");
    121.       return false;
    122.     }
    123.     else if(ret == 0)
    124.     {
    125.       std::cout<<"peer shutdown!\n";
    126.       return false;
    127.     }
    128.     body->assign(tmp,ret);//从tmp中截取ret长度大小的数据
    129.     return true;
    130.  }
    131.  
    132.  
    133.  
    134.    //接受数据
    135.    
    136.   bool Recv(std::string *body)
    137.   {
    138.     while(1)
    139.     {
    140.       char tmp[6] = {0};
    141.       int ret = recv(_sockfd,tmp,5,0);
    142.       if(ret < 0)
    143.       {
    144.          if(errno == EAGAIN)//EAGAIN这个错误表示当前缓冲区没有数据了，资源还没有准备好
    145.          {
    146.           return true;
    147.          }
    148.          perror("recv error");
    149.          return false;
    150.       }
    151.       else if(ret == 0)
    152.       {
    153.         std::cout<<"peer shutdown!\n";
    154.         return false;
    155.       }
    156.       *body += tmp;
    157.     }
    158.     return true;
    159.  }
    160.  
    161.  
    162.  
    163.    //发送数据
    164.     bool Send(const std::string &body)
    165.     {
    166.        int ret;
    167.        ret = send(_sockfd,body.c_str(),body.size(),0);
    168.        if(ret < 0)
    169.        {
    170.          perror("send error");
    171.          return false;
    172.        }
    173.      return true;
    174.     }
    175.  
    176.   //关闭套接字
    177.   bool Close()
    178.   {
    179.     if(_sockfd!= -1)
    180.     {
    181.       close(_sockfd);
    182.     }
    183.    return true;
    184.   }
    185.   
    186.  
    187.  
    188.  
    189. };

    修改tcp_srv.cpp:(创建套接字后设置非阻塞---两处）

    1. //#include "tcp_socket.hpp"
    2. //#include "select.hpp"
    3. #include "epoll.hpp"
    4. int main()
    5. {
    6.   TcpSocket lst_sock;
    7.  
    8.   //创建套接字
    9.    CHECK_RES(lst_sock.Socket());
    10.    lst_sock.SetNonBlock();
    11.   //绑定地址信息
    12.    CHECK_RES(lst_sock.Bind("0.0.0.0",20000));
    13.   //开始监听
    14.    CHECK_RES(lst_sock.Listen());
    15.  
    16.    //Select s;
    17.    Epoll s;
    18.    s.Add(lst_sock);//将监听套接字添加到集合中
    19.    while(1)
    20.    {
    21.      std::vector arry;
    22.      bool ret = s.Wait(&arry);
    23.      if(ret == false)
    24.      {
    25.       usleep(1000);
    26.       continue;
    27.      }
    28.      for(TcpSocket &a:arry)
    29.      {
    30.         //array里边就是就绪的描述符，一开始只有一个监听套接字，就绪的肯定就是监听套接字代表有新连接
    31.         if(a.GetFd()==lst_sock.GetFd())//如果就绪的套接字描述符与监听套接字描述符一样，就表示有新建连接
    32.         {
    33.           TcpSocket conn_sock;
    34.           std::string cliip;
    35.           uint16_t cliport;
    36.           bool ret = lst_sock.Accept(&conn_sock,&cliip,&cliport);
    37.           if(ret < 0)
    38.           {
    39.             continue;
    40.           }
    41.           std::cout<<"new connect:"<":"<
    42.           conn_sock.SetNonBlock();
    43.           s.Add(conn_sock);//将新建的套接字也添加监控
    44.         }
    45.         else
    46.         {
    47.           std::string buf;
    48.           ret = a.Recv(&buf);
    49.           if(ret == false)
    50.           {
    51.             s.Del(a);//出错了则移除监控
    52.             a.Close();
    53.             continue;
    54.           }
    55.           std::cout<<"client say:"<
    56.  
    57.           std::cout<<"server say:";
    58.           fflush(stdout);
    59.           std::cin>>buf;
    60.           ret = a.Send(buf);
    61.           if(ret == false)
    62.           {
    63.             s.Del(a);
    64.             a.Close();
    65.             continue;
    66.           }
    67.         }
    68.      }
    69.    }
    70.    //关闭套接字
    71.    lst_sock.Close();
    72.    return 0;
    73. }
    74.

    修改客户端tcp_cli.cpp---仍用原来的Recv方法，将其重命名为RecvCli:

    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.  //向服务器发起连接
    19.    CHECK_RES(cli_sock.Connect(srv_ip,srv_port));
    20.     cli_sock.SetNonBlock();
    21.    while(1)
    22.    {
    23.      //与服务器通信
    24.      std::string buf;
    25.      std::cout<<"client say:";
    26.      fflush(stdout);
    27.      std::cin>>buf;
    28.      bool ret = cli_sock.Send(buf);
    29.     if(ret == false)
    30.     {
    31.      cli_sock.Close();
    32.      return -1;
    33.     }
    34.     buf.clear();
    35.     ret = cli_sock.RecvCli(&buf);
    36.     if(ret == false)
    37.     {
    38.      cli_sock.Close();
    39.      return -1;
    40.     }
    41.     std::cout<<"server say:"<
    42.   }
    43.  //关闭套接字
    44.   cli_sock.Close();
    45.   return 0;
    46.  }

    测试结果：

     客户端1：

     客户端2：

     问题：如果客户端在连接后设置非阻塞，用了while循环以及新的Recv方法，则会出现：客户端输入数据会直接显示server say  client say,在服务器端输入数据在客户端是收不到的，原因有待挖掘。结果如下图：

  • 相关阅读:
    c语言单元测试构建
    P2607 [ZJOI2008] 骑士 （树形dp
    spring boot中shiro使用自定义注解屏蔽接口鉴权
    算法 旋转数组最小数字-(二分查找+反向双指针)
    CCNA-NAT协议 静态NAT 动态NAT(多对多) PAT(多对一) 内网与外网之间的通信 GNS3实验验证
    高斯判别分析（GDA）公式推导
    centos7安装mysql8
    【Nacos篇】Nacos基本操作及配置
    openEuler快速入门(二)-openEuler命令行基础操作
    rust函数
  • 原文地址：https://blog.csdn.net/weixin_46153828/article/details/126576432