网络编程-----服务器（多路复用IO 和 TCP并发模型）-EW帮帮网

一、单循环服务器模型

1. 核心特征

while(1)
			{
				newfd = accept();
					recv();
				close(newfd);
			}

2. 典型应用场景

HTTP短连接服务（早期Apache）
CGI快速处理
简单测试服务器

3. 综合代码

#include <stdio.h>
#include <sys/types.h>	       /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <strings.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, const char *argv[])
{
	if (argc != 3)
	{
		printf("Usage: %s <port> <ip>\n",argv[0]);
		return -1;
	}
	

	//1.socket 创建通信一端 
	int fd = socket(AF_INET,SOCK_STREAM,0);

	if (fd < 0)
	{
		perror("socket fail\n");
		return -1;
	}

	struct sockaddr_in seraddr;
	bzero(&seraddr,sizeof(seraddr));

	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(atoi(argv[1]));
	seraddr.sin_addr.s_addr = inet_addr(argv[2]);
	printf("fd = %d\n",fd);
    //2.bind -- 绑定服务器端的地址信息 
	if (bind(fd,(const struct sockaddr*)&seraddr,sizeof(seraddr)) < 0)
	{
		perror("connect fail");
		return -1;
	}

	printf("connect success!\n");

	//3.listen -- 设置监听 
	if (listen(fd,5) < 0)
	{
		perror("listen fail");
		return -1;
	}


	while (1)
	{
		//4.accept
		int connfd = accept(fd,NULL,NULL);

		if (connfd < 0)
		{
			perror("accept fail");
			return -1;
		}

		printf("----client --- connectted\n");

		char buf[1024];
		char sbuf[1024];
		while (1)
		{
			recv(connfd,buf,sizeof(buf),0);
			printf("c: %s\n",buf);

			if (strncmp(buf,"quit",4) == 0)
			{
				close(connfd);
				break;
			}
			sprintf(sbuf,"server + %s\n",buf);
			send(connfd,sbuf,strlen(sbuf)+1,0);
		}
	}
	close(fd);

	return 0;
}

4. 优缺点分析

优点	缺点
实现简单	无法处理并发请求
无资源竞争问题	长连接会阻塞后续请求
适合低负载场景	吞吐量低（QPS < 100）

二、多进程并发模型

1. 核心实现

while(1) {
    int newfd = accept(listen_fd, ...);
    pid_t pid = fork();
    
    if (pid == 0) {  // 子进程
        close(listen_fd);
        handle_connection(newfd);
        close(newfd);
        exit(0);
    } else if (pid > 0) {  // 父进程
        close(newfd);
        waitpid(-1, NULL, WNOHANG);  // 非阻塞回收
    }
}

2. 进程管理优化

// 使用信号处理避免僵尸进程
signal(SIGCHLD, SIG_IGN);  // 忽略子进程结束信号

// 或使用waitpid循环
while (waitpid(-1, NULL, WNOHANG) > 0);

3. 典型应用

传统Apache的prefork模式
FTP服务器
数据库连接池

4. 资源消耗对比

资源类型	进程创建开销	示例系统调用
内存	需要复制整个PCB	fork()
CPU	上下文切换成本高	schedule()
文件描述符	需要显式关闭继承的fd	close()

5. 优缺点分析

优点	缺点
可以完成多个进程的实时交互	回收资源不方便
信息的完整性可以保证。	每次fork 占用系统资源多
适合低负载场景	可能出现僵尸进程

6. 综合代码

#include <stdio.h>
#include <sys/types.h>	       /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <strings.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>

void handler(int signo)
{
	wait(NULL);
}


int init_server(const char *ip,unsigned short port)
{
	//1.socket 创建通信一端 
	int fd = socket(AF_INET,SOCK_STREAM,0);

	if (fd < 0)
	{
		perror("socket fail\n");
		return -1;
	}

	struct sockaddr_in seraddr;
	bzero(&seraddr,sizeof(seraddr));

	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(port);
	seraddr.sin_addr.s_addr = inet_addr(ip);

	//2.bind -- 绑定服务器端的地址信息 
	if (bind(fd,(const struct sockaddr*)&seraddr,sizeof(seraddr)) < 0)
	{
		perror("connect fail");
		return -1;
	}

	//3.listen -- 设置监听 
	if (listen(fd,5) < 0)
	{
		perror("listen fail");
		return -1;
	}
	return fd;
}


int client_handler(int connfd)
{
	char buf[1024];
	char sbuf[1024];
	int ret = 0;

	while (1)
	{
		ret = recv(connfd,buf,sizeof(buf),0);
		if (ret < 0)
		{
			perror("client_handler recv fail");
			ret = -1;
		}
		printf("c: %s\n",buf);

		if (strncmp(buf,"quit",4) == 0)
		{
			close(connfd);
			ret = 1;
			break;
		}
		sprintf(sbuf,"server + %s\n",buf);
		ret = send(connfd,sbuf,strlen(sbuf)+1,0);
		if (ret < 0)
		{
			perror("client_handler send fail");
			ret = -1;
		}
	}

	return ret;
	
}


int main(int argc, const char *argv[])
{
	if (argc != 3)
	{
		printf("Usage: %s <ip> <port>\n",argv[0]);
		return -1;
	}
	
	signal(SIGCHLD,handler);

	int fd = init_server(argv[1],atoi(argv[2]));
	if (fd < 0)
	{
		printf("init_server fail\n");
		return -1;
	}

	while (1)
	{
		//4.accept
		int connfd = accept(fd,NULL,NULL);

		if (connfd < 0)
		{
			perror("accept fail");
			return -1;
		}

		pid_t pid = fork();
		if (pid < 0)
		{
			perror("fork fail");
			return -1;
		}
		if (pid == 0)
		{

			int ret = 0;
			if ((ret = client_handler(connfd)) < 0)
			{
				printf("client_handler fail");
				return -1;
			}
			if (ret == 1)
			{
				printf("child exit...\n");
				exit(EXIT_SUCCESS);
			}
 
		}
	}
	close(fd);

	return 0;
}

三、多线程并发模型

1. 核心实现（POSIX线程）

while(1) {
    int newfd = accept(listen_fd, ...);
    pthread_t tid;
    pthread_create(&tid, NULL, thread_handler, (void*)newfd);
    pthread_detach(tid);  // 分离线程自动回收
}

void* thread_handler(void* arg) {
    int fd = (int)arg;
    // 处理请求
    close(fd);
    return NULL;
}

2. 线程安全控制

// 使用互斥锁保护共享资源
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void safe_write(int fd, const char* data) {
    pthread_mutex_lock(&lock);
    write(fd, data, strlen(data));
    pthread_mutex_unlock(&lock);
}

3. 典型应用

Java Tomcat
IIS应用池
实时通信服务器

4. 性能指标对比

指标	进程模型	线程模型
创建速度	慢（10-100ms）	快（0.1-1ms）
上下文切换成本	高（切换页表等）	低（共享地址空间）
内存占用	高（独立资源）	低（共享资源）

5. 优缺点分析

优点	缺点
可以完成多个进程的实时交互	线程共享进程资源
创建速度快，调度快	稳定性较差
适合低负载场景	安全性较差

6. 综合代码

#include <stdio.h>
#include <pthread.h>
#include <sys/types.h>	       /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <strings.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>
#include <errno.h>

int init_server(const char *ip,unsigned short port)
{
	//1.socket 创建通信一端 
	int fd = socket(AF_INET,SOCK_STREAM,0);

	if (fd < 0)
	{
		perror("socket fail\n");
		return -1;
	}

	struct sockaddr_in seraddr;
	bzero(&seraddr,sizeof(seraddr));

	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(port);
	seraddr.sin_addr.s_addr = inet_addr(ip);

	//2.bind -- 绑定服务器端的地址信息 
	if (bind(fd,(const struct sockaddr*)&seraddr,sizeof(seraddr)) < 0)
	{
		perror("connect fail");
		return -1;
	}

	//3.listen -- 设置监听 
	if (listen(fd,5) < 0)
	{
		perror("listen fail");
		return -1;
	}
	return fd;
}


void* client_handler(void *arg)
{
	int connfd = *(int *)arg;
	char buf[1024];
	char sbuf[1024];
	long int ret = 0;
	

	while (1)
	{
		ret = recv(connfd,buf,sizeof(buf),0);
		if (ret < 0)
		{
			perror("client_handler recv fail");
			ret = -1;
		}
		printf("c: %s\n",buf);

		if (strncmp(buf,"quit",4) == 0)
		{
			close(connfd);
			ret = 1;
			break;
		}
		sprintf(sbuf,"server + %s\n",buf);
		ret = send(connfd,sbuf,strlen(sbuf)+1,0);
		if (ret < 0)
		{
			perror("client_handler send fail");
			ret = -1;
		}
	}

	return (void*)ret;
	
}


int main(int argc, const char *argv[])
{
	if (argc != 3)
	{
		printf("Usage: %s <ip> <port>\n",argv[0]);
		return -1;
	}
	

	int fd = init_server(argv[1],atoi(argv[2]));
	if (fd < 0)
	{
		printf("init_server fail\n");
		return -1;
	}

	while (1)
	{
		//4.accept
		int connfd = accept(fd,NULL,NULL);

		if (connfd < 0)
		{
			perror("accept fail");
			return -1;
		}
		
		pthread_t tid;

		int ret = pthread_create(&tid,NULL,client_handler,&connfd);
		if(ret != 0)
		{
			errno = ret;
			perror("pthread_create fail");
			return -1;
		}
		pthread_detach(tid);//设置分离属性,由系统回收资源
	}
	close(fd);
	return 0;
}

四、并发的服务器模型 ---更高程度上的并发

`（一）fcntl` 函数与 I/O 模型详解

1. 函数原型

#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* arg */ );

2. 主要操作类型

命令	功能描述	参数要求
`F_DUPFD`	复制文件描述符	指定最小可用fd值
`F_GETFD/F_SETFD`	获取/设置文件描述符标志	标志值
`F_GETFL/F_SETFL`	获取/设置文件状态标志	新标志值
`F_GETOWN/F_SETOWN`	获取/设置异步I/O所有权	进程ID或组ID

（二）非阻塞I/O设置示例

1. 设置流程

int flag = fcntl(connfd,F_GETFL,0);
		flag = flag | O_NONBLOCK;
		fcntl(connfd,F_SETFL,flag);

2. 行为变化对比

操作	阻塞模式	非阻塞模式
`read()`	阻塞直到数据到达	立即返回，无数据时返回`EAGAIN`
`write()`	阻塞直到缓冲区空间可用	立即返回，空间不足返回`EAGAIN`
`accept()`	阻塞直到有新连接	立即返回，无连接时返回`EAGAIN`

（三）I/O 模型对比

1. 阻塞I/O模型

2. 非阻塞I/O模型

#include <stdio.h>
#include <sys/types.h>	       /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <strings.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#include <fcntl.h>
int main(int argc, const char *argv[])
{
	if (argc != 3)
	{
		printf("Usage: %s <port> <ip>\n",argv[0]);
		return -1;
	}
	

	//1.socket 创建通信一端 
	int fd = socket(AF_INET,SOCK_STREAM,0);

	if (fd < 0)
	{
		perror("socket fail\n");
		return -1;
	}

	struct sockaddr_in seraddr;
	bzero(&seraddr,sizeof(seraddr));

	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(atoi(argv[1]));
	seraddr.sin_addr.s_addr = inet_addr(argv[2]);
	printf("fd = %d\n",fd);
    //2.bind -- 绑定服务器端的地址信息 
	if (bind(fd,(const struct sockaddr*)&seraddr,sizeof(seraddr)) < 0)
	{
		perror("connect fail");
		return -1;
	}

	printf("connect success!\n");

	//3.listen -- 设置监听 
	if (listen(fd,5) < 0)
	{
		perror("listen fail");
		return -1;
	}


	while (1)
	{
		//4.accept
		int connfd = accept(fd,NULL,NULL);

		if (connfd < 0)
		{
			perror("accept fail");
			return -1;
		}

		printf("----client --- connectted\n");

		char buf[1024];
		char sbuf[1024];
	
		int flag = fcntl(connfd,F_GETFL,0);
		flag = flag | O_NONBLOCK;
		fcntl(connfd,F_SETFL,flag);
		
		while (1)
		{
			recv(connfd,buf,sizeof(buf),0);
			printf("c: %s\n",buf);

			if (strncmp(buf,"quit",4) == 0)
			{
				close(connfd);
				break;
			}
			sprintf(sbuf,"server + %s\n",buf);
			send(connfd,sbuf,strlen(sbuf)+1,0);
		}
	}
	close(fd);

	return 0;
}

（四）信号驱动 I/O 详解

1. 设置异步标志

// 获取当前文件状态标志
int flags = fcntl(fd, F_GETFL);
if (flags == -1) {
    perror("fcntl F_GETFL");
    exit(EXIT_FAILURE);
}

// 添加异步I/O标志
if (fcntl(fd, F_SETFL, flags | O_ASYNC) == -1) {
    perror("fcntl F_SETFL");
    exit(EXIT_FAILURE);
}

2. 指定信号接收者

// 设置当前进程为信号接收者
if (fcntl(fd, F_SETOWN, getpid()) == -1) {
    perror("fcntl F_SETOWN");
    exit(EXIT_FAILURE);
}

3. 注册信号处理函数

// 更安全的sigaction替代signal
struct sigaction sa;
sa.sa_flags = SA_RESTART;
sa.sa_handler = sigio_handler;
sigemptyset(&sa.sa_mask);

if (sigaction(SIGIO, &sa, NULL) == -1) {
    perror("sigaction");
    exit(EXIT_FAILURE);
}

4. 基本处理逻辑

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <signal.h>

int g_fd;

void handler(int signo)
{
	char buf[1024];
	read(g_fd,buf,sizeof(buf));

	if (strncmp(buf,"quit",4) == 0)
		return;
	printf("buf = %s\n",buf);

}

int main(int argc, const char *argv[])
{
	if (mkfifo(argv[1],0666) < 0 && errno != EEXIST)
	{
		perror("mkfifo fail");
		return -1;
	}

	printf("mkfifo success\n");

	int fd = open(argv[1], O_RDONLY);
	if (fd < 0)
	{
		perror("open fail");
		return -1;
	}

	g_fd = fd;
	int flag = fcntl(fd,F_GETFL,0);
	flag = flag | O_ASYNC;//设置为异步通信
	fcntl(fd,F_SETFL,flag);

	fcntl(fd,F_SETOWN,getpid());//所有者
	signal(SIGIO,handler);

	int i = 0;
	while (1)
	{
		printf("i = %d\n",i);
		sleep(1);
		++i;
	}

	close(fd);
	return 0;
}

5.核心局限性分析

问题类型	具体表现	解决思路
信号合并	快速连续信号可能被合并	使用实时信号（SIGRTMIN+）
多fd区分困难	无法直接判断哪个fd触发信号	每个fd绑定不同信号（不现实）
异步安全限制	信号处理函数中操作受限	仅设置标志，主循环处理
性能瓶颈	高频率信号导致CPU占用高	配合epoll使用

`（五）select` 函数详解

一、函数原型与参数解析

#include <sys/select.h>

int select(int nfds, 
           fd_set *readfds, 
           fd_set *writefds,
           fd_set *exceptfds, 
           struct timeval *timeout);

参数说明

参数	类型	说明
`nfds`	`int`	监控的文件描述符最大值 +1（优化内核检查范围）
`readfds`	`fd_set*`	监控可读事件的描述符集合（可NULL）
`writefds`	`fd_set*`	监控可写事件的描述符集合（可NULL）
`exceptfds`	`fd_set*`	监控异常事件的描述符集合（可NULL）
`timeout`	`timeval*`	超时时间：<br>• NULL：阻塞等待<br>• 0：立即返回<br>• 正数：定时等待

返回值

成功：返回就绪的文件描述符总数（可能为0）
失败：返回-1并设置errno
超时：返回0

二、核心操作宏

宏	功能	示例
`FD_ZERO`	清空描述符集合	`FD_ZERO(&read_fds);`
`FD_SET`	添加描述符到集合	`FD_SET(sockfd, &read_fds);`
`FD_CLR`	从集合中移除描述符	`FD_CLR(sockfd, &read_fds);`
`FD_ISSET`	检测描述符是否在集合中	`if(FD_ISSET(sockfd, &read_fds))`

三、典型使用流程

1. 初始化描述符集合

fd_set read_fds;
FD_ZERO(&read_fds);
FD_SET(listen_fd, &read_fds);
int max_fd = listen_fd;

2. 等待事件就绪

struct timeval tv = {5, 0}; // 5秒超时
fd_set tmp_fds = read_fds;

int ready = select(max_fd + 1, &tmp_fds, NULL, NULL, &tv);
if (ready == -1) {
    if (errno == EINTR) continue; // 处理信号中断
    perror("select error");
    break;
} else if (ready == 0) {
    printf("Timeout\n");
    continue;
}

3. 处理就绪事件

for (int fd = 0; fd <= max_fd; fd++) {
    if (FD_ISSET(fd, &tmp_fds)) {
        if (fd == listen_fd) {
            // 处理新连接
            int new_fd = accept(listen_fd, ...);
            FD_SET(new_fd, &read_fds);
            max_fd = (new_fd > max_fd) ? new_fd : max_fd;
        } else {
            // 处理客户端数据
            ssize_t n = read(fd, ...);
            if (n <= 0) {
                close(fd);
                FD_CLR(fd, &read_fds);
            }
        }
    }
}

四、关键注意事项

集合重用问题
select返回后，集合会被修改为就绪的fd集合，每次调用前必须重新初始化：
```
fd_set tmp_fds = read_fds; // 使用临时集合
```

超时时间重置
timeout参数会被修改为剩余时间，循环调用时需要重新设置：

struct timeval tv = {5, 0};
while(1) {
    select(..., &tv);
    tv.tv_sec = 5; // 必须重置
}

最大fd限制
受FD_SETSIZE限制（通常1024），超出会导致未定义行为
性能问题
每次调用需要从用户态复制整个fd_set到内核态，时间复杂度O(n)

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
int main(int argc, const char *argv[])
{
	if (mkfifo(argv[1],0666) < 0 && errno != EEXIST)
	{
		perror("mkfifo fail");
		return -1;
	}

	printf("mkfifo success\n");

	int fd = open(argv[1], O_RDONLY);
	if (fd < 0)
	{
		perror("open fail");
		return -1;
	}
	char buf[1024] = {0};

	//1.建表
	fd_set readfds;
	FD_ZERO(&readfds);

	//2.添加要关心的fd
	FD_SET(0,&readfds);
	FD_SET(fd,&readfds);

	//3.select函数监控
	fd_set backfds;
		
		struct timeval tv = {5,0};
	while(1)
	{
		backfds = readfds;//每次循环回来拿到的都是最原始数据
		int nfds = fd + 1;//因为另一个是0,所以最大也就是ｆｄ
		int ret = select(nfds,&backfds,NULL,NULL,&tv);
		if(ret < 0)
		{
			perror("select fail");
			return -1;
		}
		if(ret > 0)
		{
			for(int i = 0;i < nfds;i++)//也可以是1024,但没必要 
			{
				if(FD_ISSET(i,&backfds))
				{
					if(i == 0)
					{
						fgets(buf,sizeof(buf),stdin);
						if (strncmp(buf,"quit",4) == 0)
							break;
						printf("buf = %s\n",buf);
					}else if(i == fd)
					{
						read(fd,buf,sizeof(buf));
						if (strncmp(buf,"quit",4) == 0)
							break;
						printf("buf = %s\n",buf);
					}
				}
			}
		}
	}
	
	close(fd);
	return 0;
}

可以从客户端读取数据，也可以自身从键盘输入

tcp多客户端连接到服务器

#include <stdio.h>
#include <sys/types.h>	       /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <strings.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>

int main(int argc, const char *argv[])
{
	if (argc != 3)
	{
		printf("Usage: %s <port> <ip>\n",argv[0]);
		return -1;
	}


	//1.socket 创建通信一端 
	int fd = socket(AF_INET,SOCK_STREAM,0);

	if (fd < 0)
	{
		perror("socket fail\n");
		return -1;
	}

	struct sockaddr_in seraddr;
	bzero(&seraddr,sizeof(seraddr));

	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(atoi(argv[1]));
	seraddr.sin_addr.s_addr = inet_addr(argv[2]);
	printf("fd = %d\n",fd);
	//2.bind -- 绑定服务器端的地址信息 
	if (bind(fd,(const struct sockaddr*)&seraddr,sizeof(seraddr)) < 0)
	{
		perror("connect fail");
		return -1;
	}

	printf("connect success!\n");

	//3.listen -- 设置监听 
	if (listen(fd,5) < 0)
	{
		perror("listen fail");
		return -1;
	}


	//1.准备表 
	fd_set readfds;
	FD_ZERO(&readfds);

	//2.添加要监控的fd
	FD_SET(fd,&readfds);
	int connfd = 0;

	fd_set backfds;
	int i = 0;
	int nfds = fd + 1;
	while (1)
	{
		backfds = readfds;
		int ret = select(nfds,&backfds,NULL,NULL,NULL);

		if (ret < 0)
		{
			perror("select fail");
			return -1;
		}

		if (ret > 0)
		{
			for (i = 0; i < nfds; ++i)
			{

				if (FD_ISSET(i,&backfds))
				{
					if (i == fd)
					{
						//4.accept
						connfd = accept(fd,NULL,NULL);

						if (connfd < 0)
						{
							perror("accept fail");
							return -1;
						}

						FD_SET(connfd,&readfds);
						nfds = nfds > connfd + 1 ? nfds:connfd + 1;
					}else 
					{
						char buf[1024];
						char sbuf[1024];
						recv(i,buf,sizeof(buf),0);
						printf("c: %s\n",buf);

						if (strncmp(buf,"quit",4) == 0)
						{	
							close(i);
							FD_CLR(i,&readfds); 
						}
						sprintf(sbuf,"server + %s\n",buf);
						send(i,sbuf,strlen(sbuf)+1,0);

					}
				}
			}
		}

	}
	close(fd);

	return 0;
}

并发模型对比

模型	实现方式	优点	缺点
多进程	`fork()`	隔离性好	资源消耗大
多线程	`pthread_create()`	资源共享高效	同步复杂度高
I/O多路复用	`select/poll/epoll`	高并发低开销	编程复杂度较高
信号驱动	`SIGIO`+`fcntl`	实时性好	信号处理复杂
异步I/O	`aio_*`系列函数	真正的异步操作	系统支持不统一

`（六）epoll`

一、核心函数解析

1. `epoll_create`：创建 epoll 实例

#include <sys/epoll.h>
int epoll_create(int size);

参数：
- size：内核初始分配数据结构的建议值（Linux 2.6.8+ 后忽略，但需 > 0）
返回值：
- 成功：epoll 文件描述符 (epfd)
- 失败：-1，设置 errno
注意：
- 需手动调用 close(epfd) 释放资源
- 典型用法：epoll_create1(0)（更推荐，支持 EPOLL_CLOEXEC 标志）

2. `epoll_ctl`：管理监控列表

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

操作类型 (op)：

操作	说明
`EPOLL_CTL_ADD`	添加 fd 到监控列表（重复添加报 `EEXIST` 错误）
`EPOLL_CTL_MOD`	修改已注册 fd 的事件（未注册的 fd 报 `ENOENT` 错误）
`EPOLL_CTL_DEL`	从监控列表删除 fd（内核会忽略 event 参数）

事件结构：

struct epoll_event {
    uint32_t     events;  // 监控的事件类型（位掩码）
    epoll_data_t data;    // 用户数据（可携带 fd、指针等）
};

typedef union epoll_data {
    void    *ptr;
    int      fd;
    uint32_t u32;
    uint64_t u64;
} epoll_data_t;

3. `epoll_wait`：等待事件就绪

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

参数：
- events：输出参数，存储就绪事件数组
- maxevents：最多返回的事件数量（需 ≤ 数组长度）
- timeout：超时时间（ms），-1 表示阻塞，0 表示立即返回
返回值：
- 成功：就绪事件数量
- 超时：0
- 错误：-1，设置 errno

二、事件类型与触发模式

1. 基础事件类型

事件类型	说明
`EPOLLIN`	数据可读（包括对端关闭）
`EPOLLOUT`	数据可写（注意：可能触发虚假就绪）
`EPOLLRDHUP`	对端关闭连接或关闭写方向（需内核 ≥ 2.6.17）
`EPOLLPRI`	紧急数据可读（如 TCP 带外数据）
`EPOLLERR`	错误条件（自动监控，无需手动设置）
`EPOLLHUP`	挂起（如管道对端关闭，自动监控）

2. 高级控制标志

标志	说明
`EPOLLET`	边沿触发模式（默认水平触发 LT）
`EPOLLONESHOT`	单次触发，事件处理后需用 `EPOLL_CTL_MOD` 重新激活

三、触发模式对比

特性	水平触发 (LT)	边沿触发 (ET)
触发条件	只要缓冲区有数据/空间就会触发	仅在缓冲区状态变化时触发一次
数据读取	可部分读取，下次仍会触发	必须一次性读取到 `EAGAIN`
性能	适合低频大块数据	适合高频高并发场景
实现复杂度	简单	需配合非阻塞 I/O 和循环读写
适用场景	简单交互、文件传输	实时通信、高并发服务器

实例：

基于 epoll 的简单 TCP 服务器，可以同时处理多个客户端连接

#include <stdio.h>
#include <sys/types.h>	       /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <strings.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/epoll.h>

// 将文件描述符添加到 epoll 实例中
int add_fd(int epfd,int fd)
{
	struct epoll_event ev;
	ev.events = EPOLLIN;// 监听可读事件
	ev.data.fd = fd;// 设置文件描述符


	if(epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev) < 0)
	{
		perror("epoll_ctl fail");
		return -1;
	}
	return 0;
}
// 从 epoll 实例中删除文件描述符
int del_fd(int epfd,int fd)
{
	struct epoll_event ev;
	ev.events = EPOLLIN;
	ev.data.fd = fd;

	if(epoll_ctl(epfd,EPOLL_CTL_DEL,fd,&ev) < 0)
	{
		perror("epoll_ctl fail");
		return -1;
	}
	return 0;
}


int main(int argc, const char *argv[])
{
	if (argc != 3)
	{
		printf("Usage: %s <port> <ip>\n",argv[0]);
		return -1;
	}


	//1.socket 创建通信一端 
	int fd = socket(AF_INET,SOCK_STREAM,0);

	if (fd < 0)
	{
		perror("socket fail\n");
		return -1;
	}

	struct sockaddr_in seraddr;
	bzero(&seraddr,sizeof(seraddr));

	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(atoi(argv[1]));
	seraddr.sin_addr.s_addr = inet_addr(argv[2]);
	//2.bind -- 绑定服务器端的地址信息 
	if (bind(fd,(const struct sockaddr*)&seraddr,sizeof(seraddr)) < 0)
	{
		perror("connect fail");
		return -1;
	}

	printf("connect success!\n");

	//3.listen -- 设置监听 
	if (listen(fd,5) < 0)
	{
		perror("listen fail");
		return -1;
	}


	//1.准备表 
	int epfd = epoll_create(2);
	if(epfd < 0)
	{
		perror("epoll_create fail");
		return -1;
	}

	//2.添加要监控的fd
	add_fd(epfd,fd); // 添加监听 socket 到 epoll
	int connfd = 0;

	struct epoll_event result[1024];// 保存 epoll_wait 返回的事件
	int maxevents = 1024;//指定 epoll_wait 函数最多可以返回的事件数量。
	int ret = 0;
	int i = 0;

	int tm = 3000;//3s
	while (1)
	{// 等待 epoll 事件
		ret = epoll_wait(epfd,result,maxevents,tm);

		if (ret < 0)
		{
			perror("epoll_wait fail");
			return -1;
		}else if (ret == 0) {
			printf("epoll_wait timeout\n");//处理超时
		}else if(ret > 0)
		{
			for (i = 0; i < ret; ++i)
			{
				// 如果是监听 socket 有事件，说明有新连接
				if (result[i].data.fd == fd)//作用为监听的fd
				{
					//4.accept
					connfd = accept(fd,NULL,NULL);

					if (connfd < 0)
					{
						perror("accept fail");
						return -1;
					}
					// 将新连接的 socket 添加到 epoll
					add_fd(epfd,connfd);
				}else //通信的fd
				{
					// 处理客户端数据
					connfd = result[i].data.fd;//取触发事件的文件描述符
					char buf[1024];
					char sbuf[1024];
					recv(connfd,buf,sizeof(buf),0);
					printf("c: %s\n",buf);

					if (strncmp(buf,"quit",4) == 0)
					{	
						del_fd(epfd,connfd);
						close(connfd);
						continue;
					}
					sprintf(sbuf,"server + %s\n",buf);
					send(connfd,sbuf,strlen(sbuf)+1,0);
				}
			}
		}

	}
	close(fd);

	return 0;
}

基于 epoll 的简单 TCP 服务器，可以同时处理多个客户端连接（边沿触发模式）

#include <stdio.h>
#include <sys/types.h>	       /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <strings.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/epoll.h>
#include <errno.h>
#include <fcntl.h>

// 将文件描述符添加到 epoll 实例中
int add_fd(int epfd,int fd)
{
	struct epoll_event ev;
	ev.events = EPOLLIN|EPOLLET;// 监听可读事件，并使用边缘触发模式
	ev.data.fd = fd;// 设置文件描述符


	if(epoll_ctl(epfd,EPOLL_CTL_ADD,fd,&ev) < 0)
	{
		perror("epoll_ctl fail");
		return -1;
	}
	return 0;
}
// 从 epoll 实例中删除文件描述符
int del_fd(int epfd,int fd)
{
	struct epoll_event ev;
	ev.events = EPOLLIN;
	ev.data.fd = fd;

	if(epoll_ctl(epfd,EPOLL_CTL_DEL,fd,&ev) < 0)
	{
		perror("epoll_ctl fail");
		return -1;
	}
	return 0;
}
// 设置文件描述符为非阻塞模式
void set_nonblock(int fd)
{
	int flag = fcntl(fd,F_GETFL,0);// 获取当前文件状态标志
	flag = flag|O_NONBLOCK;// 设置非阻塞标志
	fcntl(fd,F_SETFL,flag);// 更新文件状态标志
}

int main(int argc, const char *argv[])
{
	if (argc != 3)
	{
		printf("Usage: %s <port> <ip>\n",argv[0]);
		return -1;
	}


	//1.socket 创建通信一端 
	int fd = socket(AF_INET,SOCK_STREAM,0);

	if (fd < 0)
	{
		perror("socket fail\n");
		return -1;
	}

	struct sockaddr_in seraddr;
	bzero(&seraddr,sizeof(seraddr));

	seraddr.sin_family = AF_INET;
	seraddr.sin_port = htons(atoi(argv[1]));
	seraddr.sin_addr.s_addr = inet_addr(argv[2]);
	//2.bind -- 绑定服务器端的地址信息 
	if (bind(fd,(const struct sockaddr*)&seraddr,sizeof(seraddr)) < 0)
	{
		perror("connect fail");
		return -1;
	}

	printf("connect success!\n");

	//3.listen -- 设置监听 
	if (listen(fd,5) < 0)
	{
		perror("listen fail");
		return -1;
	}


	//1.准备表 
	int epfd = epoll_create(2);
	if(epfd < 0)
	{
		perror("epoll_create fail");
		return -1;
	}

	//2.添加要监控的fd
// 添加监听 socket 到 epoll，并设置为非阻塞模式
	add_fd(epfd,fd); 
	set_nonblock(fd);

	int connfd = 0;

	struct epoll_event result[1024];// 保存 epoll_wait 返回的事件
	int maxevents = 1024;//指定 epoll_wait 函数最多可以返回的事件数量。
	int ret = 0;
	int i = 0;

	int tm = 3000;//3s
	while (1)
	{// 等待 epoll 事件
		ret = epoll_wait(epfd,result,maxevents,tm);

		if (ret < 0)
		{
			perror("epoll_wait fail");
			return -1;
		}else if (ret == 0) {
			printf("epoll_wait timeout\n");//处理超时
		}else if(ret > 0)
		{
			for (i = 0; i < ret; ++i)
			{
				// 如果是监听 socket 有事件，说明有新连接
				if (result[i].data.fd == fd)//作用为监听的fd
				{
					//4.accept
					connfd = accept(fd,NULL,NULL);

					if (connfd < 0)
					{
						perror("accept fail");
						return -1;
					}
					set_nonblock(connfd);// 设置新连接为非阻塞模式
					// 将新连接的 socket 添加到 epoll
					add_fd(epfd,connfd);
				}else //通信的fd
				{
					// 处理客户端数据
					connfd = result[i].data.fd;//取触发事件的文件描述符
					char buf[1024];
					char sbuf[1024];

					while(1)
					{
						ret = recv(connfd,buf,1,0);
						printf("c: %s\n",buf);

						if(ret < 0)
						{
							if(errno == EWOULDBLOCK||errno == EAGAIN)
								break;// 非阻塞模式下，没有更多数据可读
						}
						if (strncmp(buf,"quit",4) == 0)
						{	
							del_fd(epfd,connfd);
							close(connfd);
							continue;
						}
						sprintf(sbuf,"server + %s\n",buf);
						send(connfd,sbuf,strlen(sbuf)+1,0);
					}
				}
			}
		}

	}
	close(fd);

	return 0;
}

（七）select、poll、epoll 的比较

select 的缺点：

select 监听文件描述符最大个数为 1024。
select 监听的文件描述符集合在用户层，需要应用层和内核层互相传递数据。
select 需要循环遍历一次才能找到产生的事件。
select 只能工作在水平触发模式（低速模式），无法工作在边沿触发模式（高速模式）。

poll 的缺点：

poll 监听文件描述符不受上限限制。
poll 监听的文件描述符集合在用户层，需要内核层向用户层传递数据。
poll 需要循环遍历一次才能找到产生的事件。
poll 只能工作在水平触发模式（低速模式），无法工作在边沿触发模式（高速模式）。

epoll 的优点：

epoll 创建内核事件表，不受到文件描述符上限限制。
epoll 监听的事件表在内核中，直接在内核中监测事件效率高。
epoll 会直接获得产生事件的文件描述符的信息，而不需要遍历检测。
epoll 既能工作在水平触发模式，也能工作在边沿触发模式。

网络编程-----服务器（多路复用IO 和 TCP并发模型）

一、单循环服务器模型

1. 核心特征

2. 典型应用场景

3. 综合代码

4. 优缺点分析

二、多进程并发模型

1. 核心实现

2. 进程管理优化

3. 典型应用

4. 资源消耗对比

5. 优缺点分析

6. 综合代码

三、多线程并发模型

1. 核心实现（POSIX线程）

2. 线程安全控制

3. 典型应用

4. 性能指标对比

5. 优缺点分析

6. 综合代码

四、并发的服务器模型 ---更高程度上的并发

（一）fcntl 函数与 I/O 模型详解

1. 函数原型

2. 主要操作类型

（二）非阻塞I/O设置示例

1. 设置流程

2. 行为变化对比

（三）I/O 模型对比

1. 阻塞I/O模型

2. 非阻塞I/O模型

（四）信号驱动 I/O 详解

1. 设置异步标志

2. 指定信号接收者

3. 注册信号处理函数

4. 基本处理逻辑

5.核心局限性分析

（五）select 函数详解

一、函数原型与参数解析

参数说明

返回值

二、核心操作宏

三、典型使用流程

1. 初始化描述符集合

2. 等待事件就绪

3. 处理就绪事件

四、关键注意事项

并发模型对比

（六）epoll

一、核心函数解析

1. epoll_create：创建 epoll 实例

2. epoll_ctl：管理监控列表

3. epoll_wait：等待事件就绪

二、事件类型与触发模式

1. 基础事件类型

2. 高级控制标志

三、触发模式对比

实例：

（七）select、poll、epoll 的比较

网站公告

今日签到

热门文章

最新发布

`（一）fcntl` 函数与 I/O 模型详解

`（五）select` 函数详解

`（六）epoll`

1. `epoll_create`：创建 epoll 实例

2. `epoll_ctl`：管理监控列表

3. `epoll_wait`：等待事件就绪