服务器搭建(TCP套接字)-epoll版(服务端)

已于 2023-10-11 10:21:08 修改
阅读量599 收藏 2
点赞数 3
分类专栏： C/C++ 文章标签： 服务器 tcp/ip
于 2023-09-19 17:27:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lepaitianshi/article/details/133035990
版权

   epoll 是一种在 Linux 系统上用于高效事件驱动编程的 I/O 多路复用机制。它相比于传统的 select 和 poll 函数具有更好的性能和扩展性。

epoll 的主要特点和原理：

1、事件驱动：epoll 是基于事件驱动的模型，它通过监听事件来触发相应的回调函数，而不是像传统的阻塞模型那样持续轮询。这样可以避免无效的轮询操作，提高效率。

2、高效：epoll 使用了红黑树（rbtree）和哈希表（hash table）的数据结构来存储和管理大量的文件描述符，使得在大规模连接的情况下，对文件描述符的管理和查找操作具备较高的效率。

3、边缘触发：epoll 提供了边缘触发（edge-triggered）的工作模式。在边缘触发模式下，只有当文件描述符的状态发生变化时，epoll 才会通知应用程序。这使得应用程序能够更精确地处理事件，避免了事件的丢失和重复触发。

4、扩展性：epoll 支持高并发的连接，可以同时监听大量的文件描述符，且不随文件描述符数量的增加而性能下降。它采用了事件通知的方式，只有在文件描述符发生状态变化时才会通知应用程序，避免了大量的轮询操作。

使用 epoll 的基本步骤如下：

1、创建 epoll 实例，通过调用 epoll_create 函数创建一个 epoll 对象。

2、将需要监听的文件描述符加入 epoll 实例，通过调用 epoll_ctl 函数将文件描述符添加到 epoll 中，并指定需要监听的事件类型。
epoll_ctl 是一个用于控制 epoll 实例的系统调用函数，它用于向 epoll 实例中添加、修改或删除文件描述符及其关联的事件。

3、 进入事件循环，调用 epoll_wait 函数等待事件发生。该函数会阻塞程序执行，直到有事件发生或超时。
epoll_wait 是一个用于等待事件的系统调用函数，它在 epoll 实例上进行阻塞等待，直到有事件就绪或超时。

4、 当 epoll_wait 返回时，根据返回的就绪事件进行相应的处理。可以通过遍历返回的事件列表来获取就绪的文件描述符和事件类型。

    epoll 在网络编程中广泛应用，特别适用于高并发的服务器开发，能够处理大量的并发连接和高频率的 I/O 事件。它提供了高效的事件驱动模型，可以大大提升程序的性能和可扩展性。

一、epoll_create

int epoll_create(int size);

epoll_create 函数接受一个参数 size，该参数指定了 epoll 实例所能处理的最大文件描述符数目。它返回一个整数值，表示 epoll 实例的文件描述符，用于后续的 epoll 相关操作。

入参：
size 参数是一个提示值，用于告诉内核 epoll 实例需要处理的最大文件描述符数目。内核会根据此提示值进行一些优化，但实际上该值在大多数情况下并不会限制 epoll 实例所能处理的文件描述符数目。

返回值：

  • 成功时返回一个非负整数，表示 epoll 实例的文件描述符。
  • 如果调用失败，返回值为 -1，并设置相应的错误码，可以通过 errno 来获取具体的错误信息。

epoll_create 函数创建的 epoll 实例是默认的边缘触发模式（Edge Triggered Mode）。这意味着当文件描述符上的事件状态从未就绪变为就绪时，epoll 会返回该事件，而不是只在事件状态为就绪时返回一次。

在使用完 epoll 实例后，应当使用 close 函数显式关闭 epoll 实例的文件描述符，以释放相关资源。

二、epoll_ctl

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

入参：

  • epfd：表示 epoll 实例的文件描述符，即通过 epoll_create 创建的返回值。
  • op：表示要进行的操作类型，可以是以下三种值之一：
    • EPOLL_CTL_ADD：将文件描述符 fd 添加到 epoll 实例中，关联的事件由 event 参数指定。
    • EPOLL_CTL_MOD：修改已添加到 epoll 实例中的文件描述符 fd 的关联事件，新的事件由 event 参数指定。
    • EPOLL_CTL_DEL：从 epoll 实例中删除文件描述符 fd。
  • fd：表示要添加、修改或删除的文件描述符。
  • event：指向一个 struct epoll_event 结构体的指针，用于设置文件描述符的关联事件。
    event 字段表示要关注的事件类型，可以是以下事件类型的组合：
    • EPOLLIN：表示可读事件。
    • EPOLLOUT：表示可写事件。
    • EPOLLRDHUP：表示对端关闭连接或关闭写端。
    • EPOLLPRI：表示有紧急数据可读。
    • EPOLLERR：表示发生错误。
    • EPOLLHUP：表示连接关闭。
    • EPOLLET：使用边缘触发模式（Edge Triggered Mode）。
    • EPOLLONESHOT：在事件触发后，将文件描述符从 epoll 实例中删除，需要重新添加才能再次触发。
struct epoll_event {
    __uint32_t events;  // 表示要关注的事件类型
    epoll_data_t data;  // 用户数据，可以是文件描述符或指针
};

typedef union epoll_data {
    void *ptr;  // 指针类型的用户数据
    int fd;     // 文件描述符类型的用户数据
    __uint32_t u32;
    __uint64_t u64;
} epoll_data_t;

返回值：

  • 成功时返回 0
  • 失败时返回 -1，并设置相应的错误码，可以通过 errno 来获取具体的错误信息。

三、epoll_wait

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

入参：

  • epfd：表示 epoll 实例的文件描述符，即通过 epoll_create 创建的返回值。
  • events：指向一个 struct epoll_event 数组的指针，用于存储就绪的事件信息。
  • maxevents：表示 events 数组的大小，即最多可以存储的事件数目。
  • timeout：表示等待的超时时间，以毫秒为单位。可以是以下值之一：
    • -1：表示永久阻塞，直到有事件就绪。
    • 0：表示非阻塞，立即返回。
    • 大于 0：表示超时时间，等待指定的毫秒数后返回。

返回值：

  • epoll_wait 函数用于阻塞等待 epoll 实例上的事件就绪。当有事件就绪时，它将填充 events 数组，并返回就绪事件的数量。
  • 如果 epoll_wait 函数返回值大于 0，则表示有就绪事件，并且可以通过遍历 events 数组来获取每个就绪事件的相关信息。
  • 如果 epoll_wait 函数返回值为 0，表示超时时间到达，即没有事件就绪。
  • 如果 epoll_wait 函数返回值为 -1，表示调用出错，可以通过 errno 来获取具体的错误信息。

四、代码实现

4.1、缓存大小大于发送数据的大小

#include <iostream>
//socket
#include <sys/types.h>
#include <sys/socket.h>
//close
#include <unistd.h>
//exit
#include <stdlib.h>
//perror
#include <stdio.h>
//memset
#include <string.h>
//htons
#include <arpa/inet.h>
/* According to earlier standards */
#include <sys/time.h>
//epoll
#include <sys/epoll.h>


#define PORT 8596
#define MESSAGE_SIZE 1024
#define FD_SIZE 1024
#define MAX_EVENTS 20
#define TIME_OUT 500

int main(){

  int ret=-1;
  int socket_fd=-1;
  int accept_fd=-1;

  int backlog=10;
  int flags=1;

  struct sockaddr_in local_addr,remote_addr;

  struct epoll_event ev,events[FD_SIZE];
  int epoll_fd=-1;
  int event_number=0;

  //create socket
  socket_fd=socket(AF_INET,SOCK_STREAM,0);
  if(socket_fd == -1){
    perror("create socket error");
    exit(1);
  }
 //set option of socket
  ret = setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &flags, sizeof(flags));
  if ( ret == -1 ){
    perror("setsockopt error");
  }

 //set socket address
  local_addr.sin_family=AF_INET;
  local_addr.sin_port=htons(PORT);
  local_addr.sin_addr.s_addr=INADDR_ANY;
  bzero(&(local_addr.sin_zero),8);
 //bind socket
 ret=bind(socket_fd, (struct sockaddr *)&local_addr,sizeof(struct sockaddr_in));
 if(ret == -1){
    perror("bind socket error");
    exit(1);
 }

  ret=listen(socket_fd, backlog);
  if(ret ==-1){
   perror("listen error");
   exit(1);
  }
  //创建epoll
  epoll_fd=epoll_create(256);
  ev.data.fd=socket_fd;
  ev.events=EPOLLIN;
  //将socket_fd加入到epoll中
  epoll_ctl(epoll_fd,EPOLL_CTL_ADD,socket_fd,&ev);
  //loop to accept client
  for(;;){
   event_number=epoll_wait(epoll_fd,events,MAX_EVENTS,-1);
   for(int i=0;i<event_number;i++){
     if(events[i].data.fd==socket_fd){
      socklen_t addrlen = sizeof(remote_addr);
      accept_fd=accept(socket_fd,( struct sockaddr *)&remote_addr, &addrlen);
      ev.data.fd=accept_fd;
      ev.events=EPOLLIN | EPOLLET;
      //添加accept_fd到epoll中
      if((epoll_ctl(epoll_fd,EPOLL_CTL_ADD,accept_fd,&ev))==-1){
        close(accept_fd);
      } 
     }else if(events[i].events & EPOLLIN){
        //有数据可读
        char in_buf[MESSAGE_SIZE];
        memset(in_buf, 0, MESSAGE_SIZE);
        //receive data
        ret = recv( events[i].data.fd, &in_buf, MESSAGE_SIZE, 0 );
        if(ret <= 0){

            switch (errno){
              case EAGAIN: //暂时没有数据
                break;
              case EINTR: //被终断
                ret = recv(events[i].data.fd, &in_buf, MESSAGE_SIZE, 0);
                break;
              default:
                printf("the client is closed, fd:%d\n", events[i].data.fd);
                epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, &ev);
                close(events[i].data.fd);
                break;
            }  
        }      
               
        printf("receive message:%s\n", in_buf);
        send(events[i].data.fd, &in_buf, ret, 0);
    }
   }
 }
  printf("quit server....");
  // 关闭监听 socket 和 epoll 实例
  close(socket_fd);
  close(epoll_fd);
  return 0;
}
  • 服务端
    在这里插入图片描述
  • 客户端1
    在这里插入图片描述
  • 客户端2
    在这里插入图片描述

从代码直观就能看出epoll的代码量和逻辑实现相比select，都特别简洁。epoll 在网络编程中广泛应用，特别适用于高并发的服务器开发，能够处理大量的并发连接和高频率的 I/O 事件。它提供了高效的事件驱动模型，可以大大提升程序的性能和可扩展性。

4.2、缓存大小小于发送数据大小

4.2.1、线性触发（Level-Triggered,简称LT）

在线性触发模式下，当文件描述符上有可读、可写或异常事件发生时，epoll_wait() 函数会立即返回该事件，并且在下次调用 epoll_wait() 时仍然会返回该事件，直到应用程序处理完该事件或者文件描述符不可用（例如，读取缓冲区为空或写入缓冲区已满）为止。

#include <iostream>
//socket
#include <sys/types.h>
#include <sys/socket.h>
//close
#include <unistd.h>
//exit
#include <stdlib.h>
//perror
#include <stdio.h>
//memset
#include <string.h>
//htons
#include <arpa/inet.h>
/* According to earlier standards */
#include <sys/time.h>
//epoll
#include <sys/epoll.h>


#define PORT 8596
#define MESSAGE_SIZE 10 
#define FD_SIZE 1024
#define MAX_EVENTS 20
#define TIME_OUT 500

int main(){

  int ret=-1;
  int socket_fd=-1;
  int accept_fd=-1;

  int backlog=10;
  int flags=1;

  struct sockaddr_in local_addr,remote_addr;

  struct epoll_event ev,events[FD_SIZE];
  int epoll_fd=-1;
  int event_number=0;

  //create socket
  socket_fd=socket(AF_INET,SOCK_STREAM,0);
  if(socket_fd == -1){
    perror("create socket error");
    exit(1);
  }
 //set option of socket
  ret = setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &flags, sizeof(flags));
  if ( ret == -1 ){
    perror("setsockopt error");
  }

 //set socket address
  local_addr.sin_family=AF_INET;
  local_addr.sin_port=htons(PORT);
  local_addr.sin_addr.s_addr=INADDR_ANY;
  bzero(&(local_addr.sin_zero),8);
 //bind socket
 ret=bind(socket_fd, (struct sockaddr *)&local_addr,sizeof(struct sockaddr_in));
 if(ret == -1){
    perror("bind socket error");
    exit(1);
 }

  ret=listen(socket_fd, backlog);
  if(ret ==-1){
   perror("listen error");
   exit(1);
  }
  //创建epoll
  epoll_fd=epoll_create(256);
  ev.data.fd=socket_fd;
  ev.events=EPOLLIN;
  //将socket_fd加入到epoll中
  epoll_ctl(epoll_fd,EPOLL_CTL_ADD,socket_fd,&ev);
  //loop to accept client
  for(;;){
   event_number=epoll_wait(epoll_fd,events,MAX_EVENTS,-1);
   printf("epoll_wait:%d\n",event_number);
   for(int i=0;i<event_number;i++){
     if(events[i].data.fd==socket_fd){
      socklen_t addrlen = sizeof(remote_addr);
      accept_fd=accept(socket_fd,( struct sockaddr *)&remote_addr, &addrlen);
      ev.data.fd=accept_fd;
      ev.events=EPOLLIN;
      //添加accept_fd到epoll中
      if((epoll_ctl(epoll_fd,EPOLL_CTL_ADD,accept_fd,&ev))==-1){
        close(accept_fd);
      }
     }else if(events[i].events & EPOLLIN){
        //有数据可读
        char in_buf[MESSAGE_SIZE];
        memset(in_buf, 0, MESSAGE_SIZE);
        //receive data
        ret = recv( events[i].data.fd, &in_buf, MESSAGE_SIZE, 0 );
        if(ret <= 0){

            switch (errno){
              case EAGAIN: //说明暂时已经没有数据了，要等通知
                break;
              case EINTR: //被终断
                printf("recv EINTR... \n");
                ret = recv(events[i].data.fd, &in_buf, MESSAGE_SIZE, 0);
                break;
              default:
                printf("the client is closed, fd:%d\n", events[i].data.fd);
                epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, &ev);
                close(events[i].data.fd);
                break;
            }
        }
        printf("receive message:%s\n", in_buf);
        send(events[i].data.fd, &in_buf, ret, 0);
     }
   }
  }
  printf("quit server....");
  // 关闭监听 socket 和 epoll 实例
  close(socket_fd);
  close(epoll_fd);
  return 0;
}

在这里插入图片描述

  • MESSAGE_SIZE调整为10
  • epoll默认使用线性触发（Level-Triggered,简称LT）
  • 在线性触发的模式下，如果发送者发送的数据大于接收者缓存的大小，则会多次触发epoll_wait函数，多次读取数据，直至数据读完。

4.2.2、边缘触发（Edge-Triggered,简称ET）

在边缘触发模式下，epoll_wait() 函数只会在文件描述符上的状态发生变化时返回事件，例如由不可读变为可读或由不可写变为可写。如果文件描述符状态保持不变，epoll_wait() 不会返回该事件。

#include <iostream>
//socket
#include <sys/types.h>
#include <sys/socket.h>
//close
#include <unistd.h>
//exit
#include <stdlib.h>
//perror
#include <stdio.h>
//memset
#include <string.h>
//htons
#include <arpa/inet.h>
/* According to earlier standards */
#include <sys/time.h>
//epoll
#include <sys/epoll.h>


#define PORT 8596
#define MESSAGE_SIZE 10 
#define FD_SIZE 1024
#define MAX_EVENTS 20
#define TIME_OUT 500

int main(){

  int ret=-1;
  int socket_fd=-1;
  int accept_fd=-1;

  int backlog=10;
  int flags=1;

  struct sockaddr_in local_addr,remote_addr;

  struct epoll_event ev,events[FD_SIZE];
  int epoll_fd=-1;
  int event_number=0;

  //create socket
  socket_fd=socket(AF_INET,SOCK_STREAM,0);
  if(socket_fd == -1){
    perror("create socket error");
    exit(1);
  }
 //set option of socket
  ret = setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &flags, sizeof(flags));
  if ( ret == -1 ){
    perror("setsockopt error");
  }

 //set socket address
  local_addr.sin_family=AF_INET;
  local_addr.sin_port=htons(PORT);
  local_addr.sin_addr.s_addr=INADDR_ANY;
  bzero(&(local_addr.sin_zero),8);
 //bind socket
 ret=bind(socket_fd, (struct sockaddr *)&local_addr,sizeof(struct sockaddr_in));
 if(ret == -1){
    perror("bind socket error");
    exit(1);
 }

  ret=listen(socket_fd, backlog);
  if(ret ==-1){
   perror("listen error");
   exit(1);
  }
  //创建epoll
  epoll_fd=epoll_create(256);
  ev.data.fd=socket_fd;
  ev.events=EPOLLIN;
  //将socket_fd加入到epoll中
  epoll_ctl(epoll_fd,EPOLL_CTL_ADD,socket_fd,&ev);
  //loop to accept client
  for(;;){
   event_number=epoll_wait(epoll_fd,events,MAX_EVENTS,-1);
   printf("epoll_wait:%d\n",event_number);
   for(int i=0;i<event_number;i++){
     if(events[i].data.fd==socket_fd){
      socklen_t addrlen = sizeof(remote_addr);
      accept_fd=accept(socket_fd,( struct sockaddr *)&remote_addr, &addrlen);
      ev.data.fd=accept_fd;
      ev.events=EPOLLIN | EPOLLET;
      //添加accept_fd到epoll中
      if((epoll_ctl(epoll_fd,EPOLL_CTL_ADD,accept_fd,&ev))==-1){
        close(accept_fd);
      }
     }else if(events[i].events & EPOLLIN){
        //有数据可读
        char in_buf[MESSAGE_SIZE];
        memset(in_buf, 0, MESSAGE_SIZE);
        //receive data
        ret = recv( events[i].data.fd, &in_buf, MESSAGE_SIZE, 0 );
        if(ret <= 0){

            switch (errno){
              case EAGAIN: //说明暂时已经没有数据了，要等通知
                break;
              case EINTR: //被终断
                printf("recv EINTR... \n");
                ret = recv(events[i].data.fd, &in_buf, MESSAGE_SIZE, 0);
                break;
              default:
                printf("the client is closed, fd:%d\n", events[i].data.fd);
                epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, &ev);
                close(events[i].data.fd);
                break;
            }
        }
        printf("receive message:%s\n", in_buf);
        send(events[i].data.fd, &in_buf, ret, 0);
     }
   }
  }
  printf("quit server....");
  // 关闭监听 socket 和 epoll 实例
  close(socket_fd);
  close(epoll_fd);
  return 0;
}

在这里插入图片描述

  • ev.events=EPOLLIN | EPOLLET
    如果想设置该文件描述符是边缘触发模式，则需要在后面增加一个EPOLLET的标识符
  • 边缘触发模式下，只有文件描述符状态发生变化，才会触发epoll_wait

边缘触发（Edge-Triggered）模式相对于线性触发（Level-Triggered）模式具有以下优势：

  • 精确性：边缘触发模式只在文件描述符状态发生变化时触发事件，而不是在文件描述符可读或可写时都触发事件。这意味着边缘触发模式更加精确，只有在状态变化时才会通知应用程序，可以避免一些不必要的事件通知。

  • 高效性：由于边缘触发模式只在状态变化时触发事件，相比线性触发模式可以减少事件通知的次数，减少了不必要的系统调用。这在高并发、高吞吐量的系统中特别有效，能够提升系统的性能。

  • 解决"惊群"效应：边缘触发模式可以有效解决"惊群"效应（Thundering Herd），即当有多个线程或进程等待同一个文件描述符上的事件时，线性触发模式下可能会导致多个线程或进程同时被唤醒处理同一个事件。而边缘触发模式只会唤醒一个线程或进程处理事件，可以避免"惊群"效应。

适用场景：

  • 高性能网络服务器：对于高并发、高吞吐量的网络服务器，边缘触发模式能够更加高效地处理大量的连接和数据，并提升系统的性能。

  • 实时系统：在实时系统中，边缘触发模式能够提供更精确的事件通知，确保及时处理关键任务和事件，满足实时性要求。

  • 非阻塞式 I/O：当使用非阻塞式 I/O 进行事件驱动的编程时，边缘触发模式可以更好地控制事件的触发和处理，提供更高的灵活性和效率。

4.2.3、边缘触发（Edge-Triggered,简称ET）循环读数据

#include <iostream>
//socket
#include <sys/types.h>
#include <sys/socket.h>
//close
#include <unistd.h>
//exit
#include <stdlib.h>
//perror
#include <stdio.h>
//memset
#include <string.h>
//htons
#include <arpa/inet.h>
/* According to earlier standards */
#include <sys/time.h>
//epoll
#include <sys/epoll.h>
#include <fcntl.h>

#define PORT 8596
#define MESSAGE_SIZE 10 
#define FD_SIZE 1024
#define MAX_EVENTS 20
#define TIME_OUT 500

void set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) {
        perror("fcntl");
        exit(EXIT_FAILURE);
    }

    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("fcntl");
        exit(EXIT_FAILURE);
    }
}


int main(){

  int ret=-1;
  int socket_fd=-1;
  int accept_fd=-1;

  int backlog=10;
  int flags=1;

  struct sockaddr_in local_addr,remote_addr;

  struct epoll_event ev,events[FD_SIZE];
  int epoll_fd=-1;
  int event_number=0;
 //create socket
  socket_fd=socket(AF_INET,SOCK_STREAM,0);
  if(socket_fd == -1){
    perror("create socket error");
    exit(1);
  }
  //设置非阻塞
  set_nonblocking(socket_fd);
 //set option of socket
  ret = setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &flags, sizeof(flags));
  if ( ret == -1 ){
    perror("setsockopt error");
  }

 //set socket address
  local_addr.sin_family=AF_INET;
  local_addr.sin_port=htons(PORT);
  local_addr.sin_addr.s_addr=INADDR_ANY;
  bzero(&(local_addr.sin_zero),8);
 //bind socket
 ret=bind(socket_fd, (struct sockaddr *)&local_addr,sizeof(struct sockaddr_in));
 if(ret == -1){
    perror("bind socket error");
    exit(1);
 }

  ret=listen(socket_fd, backlog);
  if(ret ==-1){
   perror("listen error");
   exit(1);
  }
  //创建epoll
  epoll_fd=epoll_create(256);
  ev.data.fd=socket_fd;
  ev.events=EPOLLIN;
  //将socket_fd加入到epoll中
  epoll_ctl(epoll_fd,EPOLL_CTL_ADD,socket_fd,&ev);
  //loop to accept client
  for(;;){
   event_number=epoll_wait(epoll_fd,events,MAX_EVENTS,-1);
   printf("epoll_wait:%d\n",event_number);
   for(int i=0;i<event_number;i++){
     int fd=events[i].data.fd;
     if(fd==socket_fd){
      socklen_t addrlen = sizeof(remote_addr);
      accept_fd=accept(socket_fd,( struct sockaddr *)&remote_addr, &addrlen);
      //设置非阻塞
      set_nonblocking(accept_fd);
      ev.data.fd=accept_fd;
      ev.events=EPOLLIN | EPOLLET;
      //添加accept_fd到epoll中
      if((epoll_ctl(epoll_fd,EPOLL_CTL_ADD,accept_fd,&ev))==-1){
        close(accept_fd);
      }
     }else if(events[i].events & EPOLLIN){
        //有数据可读
        char in_buf[MESSAGE_SIZE];
        //receive data
        while(1){
        //清空缓存，避免数据脏读
        memset(in_buf,0,MESSAGE_SIZE);
        ret = recv( fd, &in_buf, MESSAGE_SIZE, 0 );
        if(ret == 0){
           printf("the client is closed, fd:%d\n", events[i].data.fd);
           epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, &ev);
           close(events[i].data.fd);
           break;
        }else{
            if(errno == EWOULDBLOCK || errno == EAGAIN){
                printf("read finished.....\n");
                 break;
            }
        }
        printf("epollServer receive message:%s\n", in_buf);
     }
       //  send(events[i].data.fd, &in_buf, ret, 0);
     }
   }
  }
  printf("quit server....");
  // 关闭监听 socket 和 epoll 实例
  close(socket_fd);
  close(epoll_fd);
  return 0;
}
  • recv函数是阻塞函数，服务端一定要设置非阻塞，否则循环读以后会一直阻塞，其他客户端无法再连接服务端
  • 每次读数据之前要清空缓存
余生爱静
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
使用epoll 实现TCP并发服务器
m0_71916785的博客
10-29 1555
【代码】使用epoll 实现TCP并发服务器，附【客户端】。
tcp使用epoll进行实现并发
Advsance的博客
12-13 4880
tcp使用epoll进行实现并发 tcp 服务器编写的步骤都是很熟悉的了。tcp由于每一个新的连接都会新建一个socket和客户端进行通信，但是新建立的连接在很多次之后就会管理就会出现问题，这个时候就可以使用epoll进行管理。 epoll是一种多路转接io，相比selete和poll在管理大量描述符的时候优势很明显。具体的优势我们后面可以慢慢说。 epoll的流程， 创建epoll描述符–> 添加事件–> wait; int epoll_create (int __size) __size
五分钟帮您理解Linux网络核心知识点——socket和epoll
liwenxiang629的博客
08-07 887
关于linux网络相关的基础知识点，最热的两个就是socket和epoll，接下来我就用最简单的方式把他俩说清楚便于大家理解！
TCP/IP网络编程(8)——聊天室(epoll + 线程池)
最新发布
drinkwaterwater的博客
10-09 333
在前文多线程的实现方法中，每连接一个客户端则开辟一个线程与之交互，这种情况下，当客户端连接许多时，就需要开辟非常多的线程，这是不现实的。本文我采用epoll和多线程综合的方式来实现服务端，同时添加了一些功能，并用面向对象的思想优化了代码结构。使用epoll监听文件描述符发生事件，只有当某个事件发生时，才由线程池执行代码。这样在开辟的线程个数很少的情况下依然能有很高的效率。实现功能：用户上线下线、查询在线用户、修改用户名、公聊（所有用户可见）、私聊（单一用户可见）。
C/C++开发，基于epoll的tcp-socket通信服务模块
技术需要分享
05-07 1047
最近一直研究对自己的开源物联网边缘服务瘦身，已适应更短缺资源的设备上运行，因此需要裁减第三方库的依赖，由于原先tcp-socket通信是调用第三方库的，因此准备动手为开源项目写一个简要适合项目需要的服务模块。 由于服务端需要针对每个客户端进行定制下行通讯需求，因此采用epoll以便于明确知道句柄进行特定通信。
网络编程套接字 - TCP套接字
09-08
- **tcp_v2多进程版**：多进程版本的TCP套接字可能采用了操作系统进程的概念，每个TCP连接在一个独立的进程中运行，这种方式隔离性更好，但进程间的通信和资源管理相对复杂。 每种实现都有其优缺点，例如多线程可以...
MFC的TCP套接字服务端程序代码
05-12
总的来说，"MFC的TCP套接字服务端程序代码"涉及了C++、MFC框架、TCP网络通信和多线程编程等多个方面的知识。通过分析提供的源代码和文档，开发者可以深入理解MFC如何简化网络编程，以及如何构建一个健壮的TCP服务器...
c++套接字实现TCP通讯客户端以及服务端.rar
01-11
c++套接字实现TCP通讯，已经封装好成类，demo是MFC写的客户端以及服务端 上传文档可以参考： https://www.cnblogs.com/cswuyg/p/3185164.html
易语言-TCP套接字实现的HTTP服务器
06-28
《易语言TCP套接字实现的HTTP服务器详解》 在IT行业中，网络编程是一项至关重要的技能，而HTTP服务器则是互联网应用的基础。本文将深入探讨如何使用易语言通过TCP套接字来实现一个简单的HTTP服务器，这对于我们理解...
在C的TCP客户端和服务器套接字的实现
06-26
本文将详细讲解如何在C语言中实现TCP客户端和服务器套接字，主要关注Socket API的使用，以及针对UNIX/Linux系统的编程。 首先，让我们了解TCP的基本原理。TCP确保数据的有序传输，并通过确认机制保证数据的完整性。...
linux epoll服务器
05-05
linux 下用epoll写tcp服务器的完整例子，还有通用makefile的例子。是一个学习linux服务器编程的好例子。
使用epoll的客户服务器端例子
04-11
客户端使用的是tcpclipoll.c,服务器使用的是tcpsrvepoll.c.给出了Makefile文件
linux socket tcp大并发 epoll使用教程 有关epoll的一切
01-19
linux socket tcp大并发 epoll使用教程 有关epoll的一切
linux上的epoll如何使用，并用C++实现多客户端服务器
CHNIM的博客
05-26 652
是Linux系统中的一种高效的I/O多路复用机制，可以用于实现高并发的网络服务器。的代码相对复杂，需要理解非阻塞I/O、事件驱动编程等概念。实现多客户端服务器的基本步骤，需要注意的是，
epoll高度封装reactor,几乎所有可见服务器的底层框架
小杰312的博客
04-02 5188
epoll高度封装reactor,几乎所有可见服务器的底层框架
epoll服务器
coolwriter的博客
06-08 420
epoll同上篇博客中的select一样，都是用于多路转接，但epoll被公认为Linux2.6下性能最好的多路I/O就绪通知方法。   一、epoll相关系统调用 epoll只有三个系统调用函数： epoll_create：创建epoll模型 epoll_ctl：管理epoll模型 epoll_wait：等待I/O时间就绪   events可以是以下几个宏的集合： EPOL...
Epoll的本质（内部实现原理）
k916631305的博客
11-06 1595
转自：https://zhuanlan.zhihu.com/p/63179839 作者：罗培羽 从事服务端开发，少不了要接触网络编程。epoll作为linux下高性能网络服务器的必备技术至关重要，nginx、redis、skynet和大部分游戏服务器都使用到这一多路复用技术。 因为epoll的重要性，不少游戏公司（如某某九九）在招聘服务端同学时，可能会问及epoll相关的问题。比如epoll和select的区别是什么？epoll高效率的原因是什么？如果只靠背诵，显然不能算上深刻的理解。 网上虽.
使用epoll实现TCP多路复用
Cashey1991的专栏
04-09 2492
epoll极简介绍 epoll_create 创建一个epoll内核对象，返回指向该对象的fd epoll_ctl 往epoll中添加、删除、修改需要监控的套接字 epoll_wait 等待epoll中的套接字产生可读、可写、异常消息
epoll实现tcp百万级高并发测试
u014220105的博客
12-06 3921
**epoll实现高并发测试** 1,准备环境 Server 端： 系统端口限制 默认查看：cat /proc/sys/net/ipv4/ip_local_port_range 32768 60999（在/etc/sysctl.conf修改） 最大文件句柄限制：查看：cat /proc/sys/fs/file-nr 297440 0 297373（最大值系统计算） 备注：这里最大...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值