epoll 在客户端断开连接时循环

我正在尝试使用 epoll 来实现套接字服务器。我有 2 个线程执行 2 个任务：

1. 侦听传入连接
2. 在屏幕上写入客户端正在发送的数据。

对于我的测试，我将客户端和服务器放在同一台计算机上，运行 3 或 4 个客户端。服务器工作正常，直到我没有通过发出CTRL-C来杀死其中一个客户端：一旦我这样做，服务器就会开始循环并以非常快的速度打印来自其他客户端的数据。奇怪的是，

1. 客户端每 2 秒发送一次数据，但服务器的速率更高
2. epoll_wait也应该在其中一个客户端断开连接时打印一些东西，因为它也在检查 EPOLLHUP 或 EPOLLERR
。
3. epoll_wait打印前应该等一会儿，因为我给了他 3000 毫秒的超时。

你能帮忙吗？可能是我以错误的方式将 epoll 描述符传递给另一个线程吗？我无法理解，因为代码看起来与周围的许多示例相似。

多谢

锰

 // server.cpp
 #include <iostream>
 #include <cstdio>
 #include <cstring>
 extern "C" {
 #include <sys/epoll.h>    
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <netdb.h>
 #include <pthread.h>
 }
 #define MAX_BACKLOG 10
 void* readerthread(void* args){
     int epfd = *((int*)args);
     epoll_event outwait[10];
     while(true){
         int retpw = epoll_wait( epfd, outwait,20, 3000 );
         if( retpw == -1 ){
         printf("epoll error %mn");
         }else if( retpw == 0 ){
         printf("nothing is ready yetn");
         continue;
         }else{
             for( int i=0;i<retpw;i++){
                 if( outwait[i].events & EPOLLIN ){
                     int fd = outwait[i].data.fd;   
                     char buf[64];
                     if( -1 == read(fd,buf,64) ){
                         printf("error reading %mn");
                     }
                     printf("%sn",buf);
                 }else{
                     std::cout << "other event" << std::endl;
                 }                  
             }
         }
     }  
 }
 int main(){ 
      int epfd = epoll_create(10);
      if( -1 == epfd ){
      std::cerr << "error creating EPOLL server" << std::endl;
      return -1;
      }
      pthread_t reader;
      int rt = pthread_create( &reader, NULL, readerthread, (void*)&epfd );
      if( -1 == rt ){
      printf("thread creation %mn");
      return -1;
      }

      struct addrinfo addr;
      memset(&addr,0,sizeof(addrinfo));
      addr.ai_family   = AF_INET;
      addr.ai_socktype = SOCK_STREAM;
      addr.ai_protocol = 0;
      addr.ai_flags    = AI_PASSIVE;
      struct addrinfo * rp,* result;
      getaddrinfo( "localhost","59000",&addr,&result );
      for( rp = result; rp != NULL; rp = rp->ai_next ){
      // we want to take the first ( it could be IP_V4 
      // or IP_V6 )
      break;
      }     
      int sd = socket( AF_INET, SOCK_STREAM, 0 );
      if(-1==sd ){
      std::cerr << "error creating the socket" << std::endl;
      return -1;        
      }
      // to avoid error 'Address already in Use'
      int optval = 1;
      setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));         
      if( -1==bind( sd, result->ai_addr, result->ai_addrlen ) ){
      printf("%mn");
      std::cerr << "error binding" << std::endl;
      return -1;
      }
      while(true){
           std::cout << "listen" << std::endl;
           if( -1== listen(sd, MAX_BACKLOG ) ){
               std::cerr << "listen didn't work" << std::endl;
               return -1;
           }
           std::cout << "accept" << std::endl;
           sockaddr peer;
              socklen_t addr_size; 
           int pfd = accept( sd, &peer ,&addr_size );
           if( pfd == -1 ){
               std::cerr << "error calling accept()" << std::endl;
               return -1;
           }
           epoll_event ev;
           ev.data.fd = pfd;
           ev.events =  EPOLLIN;
           std::cout << "adding to epoll list" << std::endl;
           if( -1 == epoll_ctl( epfd, EPOLL_CTL_ADD, pfd, &ev ) ){
               printf("epoll_ctl error %mn");
               return -1;
           }
      }
 }
 // end of server.cpp

 // client.cpp
     #include <iostream>
 #include <cstring>
 #include <cstdio>
 extern "C"{
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <netdb.h>
 }
 int main(){
      const char* servername = "localhost";
      const char* serverport = "59000";
      struct addrinfo server_address;
      memset( &server_address, 0, sizeof(struct addrinfo) );
      server_address.ai_family  =  AF_INET;
      server_address.ai_socktype =  SOCK_STREAM;
      server_address.ai_protocol  =  0; // any protocol
      server_address.ai_flags    =  0;
      struct addrinfo * result, * rp;
      int res = getaddrinfo( servername, serverport, &server_address, &result );
      if( -1 == res ){
         std::cout << "I cannot getaddress " << servername << std::endl;
         return -1;
      }
      int fd = socket( server_address.ai_family
                , server_address.ai_socktype
                , server_address.ai_protocol );
      if( -1 == fd ){
      printf("I cannot open a socket %mn");
            return -1;
      } 
     for( rp = result; rp != NULL; rp = rp->ai_next ){
         std::cout << "************" << std::endl;
        if( -1 == connect( fd, rp->ai_addr, rp->ai_addrlen ) ){
             close(fd);
         }else{
         std::cout << "connected" << std::endl;
         break;
       }
     }
     if( rp == NULL ){
         std::cerr << "I couldn't connect server " << servername << std::endl;
     }
     while(true){
         sleep(2);
         pid_t me = getpid();
         char buf[64];
         bzero( buf,sizeof(buf));
         sprintf( buf,"%ld",me );
         write(fd,buf,sizeof(buf));
         printf("%sn",buf);
      }
 }
 // end of client.cpp