IO多路复用 --select、poll、epoll模式

最新推荐文章于 2024-08-28 07:49:04 发布
最新推荐文章于 2024-08-28 07:49:04 发布
阅读量788 收藏
点赞数
分类专栏： 网络 文章标签： epoll select poll linux网络编程 IO多路复用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FreeeLinux/article/details/52678985
版权

一：select模式

头文件： 
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/select.h>

#define MAX_LINE   1024
#define MAX_SIZE   10
#define IP_ADDR    "127.0.0.1"
#define PORT       8787
#define MAX_LISTEN 5

#define _DEBUG_
服务器端： 
#include "utili.h"

typedef struct vector_fd{
	int    maxfd;
	int    cli_count;
	int    cli_fds[MAX_SIZE];
	fd_set allfds;
} vector_fd;

static vector_fd* vector_fd_ptr = NULL;

static void init_vector_fd()
{
	vector_fd_ptr = (vector_fd *)malloc(sizeof(vector_fd));
	assert(vector_fd_ptr != NULL);
	memset(vector_fd_ptr, 0, sizeof(vector_fd));
	for(int i=0; i<MAX_SIZE; ++i)
		vector_fd_ptr->cli_fds[i] = -1;
}

static void destroy_vector_fd()
{
	if(vector_fd_ptr != NULL){
		free(vector_fd_ptr);
		vector_fd_ptr = NULL;
	}
}

static int indexof(const int connfd)
{
	for(int i=0; i<vector_fd_ptr->cli_count; ++i){
		if(vector_fd_ptr->cli_fds[i] == connfd)
			return i;
	}
}

static void remove_vector_fd(const int connfd)
{
#ifdef _DEBUG_
	printf("client : %d got died.\n", indexof(connfd));
#endif
	close(connfd);
	vector_fd_ptr->cli_fds[indexof(connfd)] = -1;
}

static int create_server_proc(const char *ip, const int port)
{
	assert(ip != NULL);

	int listenfd;
	listenfd = socket(AF_INET, SOCK_STREAM, 0);
	assert(listenfd != -1);
	
	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(port);
	servaddr.sin_addr.s_addr = inet_addr(ip);

	int on = 1;
	setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

	int ret;
	ret = bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
	assert(ret != -1);

	ret = listen(listenfd, MAX_LISTEN);
	assert(ret != -1);

	return listenfd;
}

static void accept_event_handler(const int listenfd)
{
	int connfd;
	if( (connfd = accept(listenfd, NULL, NULL)) < 0)
		ERR_EXIT("accept error.");
	int i;
	for(i=0; i<MAX_SIZE && vector_fd_ptr->cli_fds[i]!=-1; ++i);
	if(i != MAX_SIZE){
#ifdef _DEBUG_
		printf("client : %d connected.\n", i);
#endif
		vector_fd_ptr->cli_fds[i] = connfd;
		++vector_fd_ptr->cli_count;   //notice, when client connected, do ++cli_count
	}
	else
		printf("too many client.\n");
}

static void communication_detail(const int connfd)
{
	char buffer[MAX_LINE];
	int ret;
	
	ret = recv(connfd, buffer, sizeof(buffer), 0);
	assert(ret != -1);
	
	if(ret == 0){
#ifdef _DEBUG_
		printf("client : %d close.\n", indexof(connfd));
#endif
		remove_vector_fd(connfd);
		return;
	}

	fprintf(stdout, "%s", buffer);
	ret = send(connfd, buffer, strlen(buffer)+1, 0);
	assert(ret != -1);
}

static void connected_event_handler(fd_set *readfds)
{
	int clifd;
	for(int i=0; i<vector_fd_ptr->cli_count; ++i){
		clifd = vector_fd_ptr->cli_fds[i];
		if(clifd < 0)
			continue;
		
		if(FD_ISSET(clifd, readfds)){
			communication_detail(clifd);		
			break;
		}
	}
}

static void manage_client_proc(const int listenfd)
{
	fd_set* readfds = &vector_fd_ptr->allfds;
	vector_fd_ptr->maxfd = listenfd;

	for(; ;){
		FD_ZERO(readfds);
		FD_SET(listenfd, readfds);
		for(int i=0; i<vector_fd_ptr->cli_count; ++i){
			int clifd = vector_fd_ptr->cli_fds[i];
			FD_SET(clifd, readfds);
			vector_fd_ptr->maxfd = clifd > vector_fd_ptr->maxfd ? 
										   clifd : vector_fd_ptr->maxfd;
		}
		
		int ret;
		struct timeval tv = {5, 0};
		if( (ret = select(vector_fd_ptr->maxfd+1, readfds, NULL, NULL, &tv)) < 0)
			ERR_EXIT("select error.");
		else if(ret == 0){          //when tv is set to {0, 0}, always timeout
			printf("time out and reselect.\n");
			continue;
		}
		else{
			if(FD_ISSET(listenfd, readfds)){
#ifdef _DEBUG_
				printf("the client connecting.\n");
#endif
				accept_event_handler(listenfd);
			}
			else{
				connected_event_handler(readfds);
			}
		}
	}
}

int main()
{
	int listenfd = create_server_proc(IP_ADDR, PORT);
	init_vector_fd();
	manage_client_proc(listenfd);
	destroy_vector_fd();
	return 0;
}
客户端： 
#include "utili.h"

static int create_socket_proc()
{
	int sockfd;
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	assert(sockfd != -1);

	return sockfd;
}

static int connect_server_proc(int sockfd, const char* ip, const int port)
{
	assert(ip != NULL && port > 0);

	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(port);
	servaddr.sin_addr.s_addr = inet_addr(ip);

	int ret;
	ret = connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
	assert(ret != -1);

	return 0;
}

static int connected_event_handler(int sockfd)
{
	fd_set new_set;
	char buffer[MAX_LINE];
	
	fgets(buffer, sizeof(buffer), stdin);
	int ret = send(sockfd, buffer, strlen(buffer)+1, 0);
	assert(ret != -1);

	int maxfd = sockfd;
	for(; ;){
		FD_ZERO(&new_set);
		FD_SET(sockfd, &new_set);

		ret = select(maxfd+1, &new_set, NULL, NULL, NULL);
		assert(ret != -1);
		
		if(FD_ISSET(sockfd, &new_set)){
			ret = recv(sockfd, buffer, sizeof(buffer), 0);
			assert(ret != -1);

			fputs(buffer, stdout);
			fgets(buffer, sizeof(buffer), stdin);
			
			ret = send(sockfd, buffer, strlen(buffer)+1, 0);
			assert(ret != -1);
		}
	}
}

int main()
{
	int sockfd = create_socket_proc();	
	connect_server_proc(sockfd, IP_ADDR, PORT);
	connected_event_handler(sockfd);
	return 0;
}

二：poll模式

头文件： 
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <assert.h>
#include <poll.h>

#define IP_ADDR      "127.0.0.1"
#define PORT         8787
#define CLIENT_SIZE  10
#define LISTEN_SIZE  5
#define BUFFER_SIZE  256

#define _DEBUG_
服务器端： 
#include "utili.h"

static int create_socket_proc(const char *ip, const int port)
{
	int listenfd = socket(AF_INET, SOCK_STREAM, 0);
	assert(listenfd != 0);

	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(port);
	servaddr.sin_addr.s_addr = inet_addr(ip);

	int on = 1;
	int ret = setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
	assert(ret != -1);

	ret = bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
	assert(ret != -1);

	ret = listen(listenfd, LISTEN_SIZE);
	assert(ret != -1);

	return listenfd;
}

static void accept_client_proc(struct pollfd (*clifds)[CLIENT_SIZE], const int listenfd, int* maxi)
{
	int connfd = accept(listenfd, NULL, NULL);
	assert(connfd != -1);

	int i;
	for(i=1; i<CLIENT_SIZE && (*clifds)[i].fd!=-1; ++i);
	if(i != CLIENT_SIZE){
		(*clifds)[i].fd = connfd;
		(*clifds)[i].events = POLLIN;
#ifdef _DEBUG_
		printf("%d has connected.\n", i);
#endif
	}
	else
		printf("too many clients.\n");
	
	if(i > *maxi)
		*maxi = i;
}

static void remove_client_fd(struct pollfd *clifds, const int index)
{
	close(clifds[index].fd);
	clifds[index].fd = -1;
}

static void connected_client_proc(struct pollfd *clifds, const int maxi)
{
	char buffer[BUFFER_SIZE];
	for(int i=1; i<=maxi; ++i){        //maxi is the max index, not the max quantity
		if(clifds[i].fd < 0)
			continue;

		int sockfd = clifds[i].fd;
		if(clifds[i].revents & POLLIN){
#ifdef _DEBUG_
			printf("it is from %dth message.\n", i);
#endif
			int recv_sz = recv(sockfd, buffer, sizeof(buffer), 0);
			assert(recv_sz != -1);

			if(recv_sz == 0){
				remove_client_fd(clifds, i);
				break;
			}
			
			fputs(buffer, stdout);
			int ret = send(sockfd, buffer, strlen(buffer)+1, 0);
			assert(ret != -1);

			break;
		}
	}
}

static void do_poll(int listenfd)
{
	struct pollfd clifds[CLIENT_SIZE];	
	clifds[0].fd = listenfd;
	clifds[0].events = POLLIN;
	for(int i=1; i<CLIENT_SIZE; ++i)
		clifds[i].fd = -1;
	
	int maxi = 0;
	for(; ;){
#ifdef _DEBUG_
	printf("before poll function.\n");
#endif
		int ret = poll(clifds, maxi+1, -1);      
		assert(ret != -1);
#ifdef _DEBUG_
	printf("after poll function.\n");
#endif
		if(clifds[0].revents & POLLIN){
			accept_client_proc(&clifds, listenfd, &maxi);
		}

		connected_client_proc(clifds, maxi);
	}
}

int main()
{
	int listenfd = create_socket_proc(IP_ADDR, PORT);
	do_poll(listenfd);
	return 0;
}
客户端： 
#include "utili.h"

static int create_socket_proc()
{
	int sockfd;
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	assert(sockfd != -1);

	return sockfd;
}

static int connect_server_proc(int sockfd, const char* ip, const int port)
{
	assert(ip != NULL && port > 0);

	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(port);
	servaddr.sin_addr.s_addr = inet_addr(ip);

	int ret;
	ret = connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
	assert(ret != -1);

	return 0;
}

static void connected_event_handler(const int sockfd)
{
	struct pollfd fds[2];
	fds[0].fd = sockfd;
	fds[0].events = POLLIN;
	fds[1].fd = STDIN_FILENO;
	fds[1].events = POLLIN;

	char buffer[BUFFER_SIZE];
	for(; ;){
		int ret = poll(fds, 2, -1);   //2 for sockfd or STDIN_FILENO
		assert(ret != -1);

		if(fds[0].revents & POLLIN){
			int recv_sz = recv(sockfd, buffer, sizeof(buffer), 0);
			assert(recv_sz != -1);
			
			if(recv_sz == 0){
				close(sockfd);
				return;
			}
			fputs(buffer, stdout);
		}
		else if(fds[1].revents & POLLIN){
			int ret;
			ret = read(STDIN_FILENO, buffer, sizeof(buffer));
			assert(ret != -1);
			buffer[ret] = '\0';
			
			ret = send(sockfd, buffer, strlen(buffer)+1, 0);
			assert(ret != -1);
		}
	}

}

int main()
{
	int sockfd = create_socket_proc();
	connect_server_proc(sockfd, IP_ADDR, PORT);
	connected_event_handler(sockfd);
	return 0;
}

三：epoll模式

头文件： 
#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<assert.h>
#include<sys/epoll.h>

#define IP_ADDR      "127.0.0.1"
#define PORT         8787
#define LISTEN_SIZE  5
#define BUFFER_SIZE  1024
#define EPOLL_EVENTS 100
#define FD_SIZE      1000
服务器端： 
#include "utili.h"

static int  create_listen_proc(const char* ip, const int port);
static void do_epoll(const int listenfd);
static void events_handler(const int epollfd, struct epoll_event *events, 
					  const int num, const int listenfd, char* buffer);
static void do_accept(const int epollfd, const int listenfd);
static void do_read(const int epollfd, const int fd, char* buffer);
static void do_write(const int epollfd, const int fd, char *buffer);
static void add_event(const int epollfd, const int fd, const int state);
static void delete_event(const int epollfd, const int fd, const int state);
static void modify_event(const int epollfd, const int fd, const int state);

int main()
{
	int listenfd = create_listen_proc(IP_ADDR, PORT);
	do_epoll(listenfd);
	return 0;
}

static void add_event(const int epollfd, const int fd, const int state)
{
	struct epoll_event ev;
	ev.events = state;
	ev.data.fd = fd;
	epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev);
}
static void delete_event(const int epollfd, const int fd, const int state)
{
	struct epoll_event ev;
	ev.events = state;
	ev.data.fd = fd;
	epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, &ev);
}
static void modify_event(const int epollfd, const int fd, const int state)
{
	struct epoll_event ev;
	ev.events = state;
	ev.data.fd = fd;
	epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &ev);
}

static void do_accept(const int epollfd, const int listenfd)
{
	int connfd = accept(listenfd, NULL, NULL);
	assert(connfd != -1);
	add_event(epollfd, connfd, EPOLLIN);    //add connfd to epollfd
}

static void do_read(const int epollfd, const int fd, char* buffer)
{
	int read_sz = read(fd, buffer, BUFFER_SIZE);
	assert(read_sz != -1);
	buffer[read_sz] = '\0';

	if(read_sz == 0){
		close(fd);
		delete_event(epollfd, fd, EPOLLIN);
	}
	else{
		fputs(buffer, stdout);
		modify_event(epollfd, fd, EPOLLOUT);
	}
}

static void do_write(const int epollfd, const int fd, char *buffer)
{
	int ret = write(fd, buffer, strlen(buffer));
	assert(ret != -1);

	modify_event(epollfd, fd, EPOLLIN);
}

static void events_handler(const int epollfd, struct epoll_event *events, 
					  const int num, const int listenfd, char* buffer)
{
	for(int i=0; i<num; ++i){
		int fd = events[i].data.fd;
		if((fd == listenfd) && (events[i].events & EPOLLIN)){
#ifdef _DEBUG_
			printf("accept client.\n");
#endif
			do_accept(epollfd, listenfd);
		}
		else if(events[i].events & EPOLLIN){
#ifdef _DEBUG_
			printf("read from client.\n");
#endif
			do_read(epollfd, fd, buffer);
		}
		else if(events[i].events & EPOLLOUT){
#ifdef _DEBUG_
			printf("write to client.\n");
#endif
			do_write(epollfd, fd, buffer);
		}
	}
}

static void do_epoll(const int listenfd)
{
	int epollfd;
	struct epoll_event events[EPOLL_EVENTS];
	char buffer[BUFFER_SIZE];

	memset(buffer, 0, sizeof(buffer));
	epollfd = epoll_create(FD_SIZE);        //don't leave
	add_event(epollfd, listenfd, EPOLLIN);
	for(; ;){
#ifdef _DEBUG_
		printf("before epoll\n");
#endif
		int ret = epoll_wait(epollfd, events, EPOLL_EVENTS, -1);
#ifdef _DEBUG_
		printf("after epoll\n");
#endif
		events_handler(epollfd, events, ret, listenfd, buffer);
	}
}

static int create_listen_proc(const char* ip, const int port)
{
	int listenfd = socket(AF_INET, SOCK_STREAM, 0);
	assert(listenfd != -1);

	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(port);
	servaddr.sin_addr.s_addr = inet_addr(ip);

	int on = 1;
	setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

	int ret;
	ret = bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
	assert(ret != -1);

	ret = listen(listenfd, LISTEN_SIZE);
	assert(ret != -1);

	return listenfd;
}
客户端： 
#include "utili.h"

static int create_connection_proc(const char* ip, const int port);
static void connection_handler(const int sockfd);
static void do_read(const int epollfd, const int fd, const int sockfd, char* buffer);
static void do_write(const int epollfd, const int fd, char* buffer);
static void add_event(const int epollfd, const int fd, const int state);
static void delete_event(const int epollfd, const int fd, const int state);
static void modify_event(const int epollfd, const int fd, const int state);

int main()
{
	int sockfd = create_connection_proc(IP_ADDR, PORT);
	connection_handler(sockfd);
	return 0;
}

static void add_event(const int epollfd, const int fd, const int state)
{
	struct epoll_event ev;
	ev.events = state;
	ev.data.fd = fd;
	epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev); 
}

static void delete_event(const int epollfd, const int fd, const int state)
{
	struct epoll_event ev;
	ev.events = state;
	ev.data.fd = fd;
	epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, &ev);
}

static void modify_event(const int epollfd, const int fd, const int state)
{
	struct epoll_event ev;
	ev.events = state;
	ev.data.fd = fd;
	epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &ev);
}

static void do_read(const int epollfd, const int fd, const int sockfd, char* buffer)
{
	int read_sz = read(fd, buffer, BUFFER_SIZE);
	assert(read_sz != -1);
	buffer[read_sz] = '\0';

	if(read_sz == 0){
		close(fd);
		delete_event(epollfd, fd, EPOLLIN);
	}
	else{
		if(fd == STDIN_FILENO)
			add_event(epollfd, sockfd, EPOLLOUT);
		else{
			fputs(buffer, stdout);
			delete_event(epollfd, fd, EPOLLIN);    //fd = sockfd
			add_event(epollfd, STDIN_FILENO, EPOLLOUT);
		}
	}
}

static void do_write(const int epollfd, const int fd, char* buffer)
{
	int ret = write(fd, buffer, strlen(buffer));
	assert(ret != -1);

	if(fd == STDIN_FILENO)
		delete_event(epollfd, STDIN_FILENO, EPOLLOUT);
	else
		modify_event(epollfd, fd, EPOLLIN);       //fd = sockfd
}

static void events_handler(const int epollfd, struct epoll_event *events,
						   const int num, const int sockfd, char* buffer)
{
	for(int i=0; i<num; ++i){
		int fd = events[i].data.fd;
		if(events[i].events & EPOLLIN){
#ifdef _DEBUG_
			printf("read\n");
#endif
			do_read(epollfd, fd, sockfd, buffer);
		}
		else if(events[i].events & EPOLLOUT){
#ifdef _DEBUG_
			printf("write\n");
#endif
			do_write(epollfd, fd, buffer);
		}
	}
}

static void connection_handler(const int sockfd)
{
	int epollfd;
	struct epoll_event events[EPOLL_EVENTS];
	char buffer[BUFFER_SIZE];
	
	memset(buffer, 0, sizeof(buffer));
	epollfd = epoll_create(FD_SIZE);
	add_event(epollfd, STDIN_FILENO, EPOLLIN);
	for(; ;){
#ifdef _DEBUG_
		printf("before epoll\n");
#endif
		int ret = epoll_wait(epollfd, events, EPOLL_EVENTS, -1);
#ifdef _DEBUG_
		printf("after epoll\n");
#endif
		events_handler(epollfd, events, ret, sockfd, buffer);
	}
}

static int create_connection_proc(const char* ip, const int port)
{
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	assert(sockfd != -1);

	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(port);
	servaddr.sin_addr.s_addr = inet_addr(ip);

	int ret = connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
	assert(ret != -1);

	return sockfd;
}

*以上代码均经过测试。


ET模式：
因为ET模式只有从unavailable到available才会触发，所以
1、读事件：需要使用while循环读取完，一般是读到EAGAIN，也可以读到返回值小于缓冲区大小；
如果应用层读缓冲区满：那就需要应用层自行标记，解决OS不再通知可读的问题
2、写事件：需要使用while循环写到EAGAIN，也可以写到返回值小于缓冲区大小
如果应用层写缓冲区空（无内容可写）：那就需要应用层自行标记，解决OS不再通知可写的问题。
 
LT模式：
因为LT模式只要available就会触发，所以：
1、读事件：因为一般应用层的逻辑是“来了就能读”，所以一般没有问题，无需while循环读取到EAGAIN；
如果应用层读缓冲区满：就会经常触发，解决方式如下；
2、写事件：如果没有内容要写，就会经常触发，解决方式如下。
 
LT经常触发读写事件的解决办法：修改fd的注册事件，或者把fd移出epollfd。
 
总结：
目前好像还是LT方式应用较多，包括redis、libuv等。（nginx使用ET）
LT模式的优点在于：事件循环处理比较简单，无需关注应用层是否有缓冲或缓冲区是否满，只管上报事件。缺点是：可能经常上报，可能影响性能。



ET本身并不会造成饥饿，由于事件只通知一次，开发者一不小心就容易遗漏了待处理的数据，像是饥饿，实质是bug
使用ET模式，特定场景下会比LT更快，因为它可以便捷的处理EPOLLOUT事件，省去打开与关闭EPOLLOUT的epoll_ctl（EPOLL_CTL_MOD）调用。从而有可能让你的性能得到一定的提升。
例如你需要写出1M的数据，写出到socket 256k时，返回了EAGAIN，ET模式下，当再次epoll返回EPOLLOUT事件时，继续写出待写出的数据，当没有数据需要写出时，不处理直接略过即可。而LT模式则需要先打开EPOLLOUT，当没有数据需要写出时，再关闭EPOLLOUT（否则会一直返回EPOLLOUT事件）
总体来说，ET处理EPOLLOUT方便高效些，LT不容易遗漏事件、不易产生bug
如果server的响应通常较小，不会触发EPOLLOUT，那么适合使用LT，例如redis等。而nginx作为高性能的通用服务器，网络流量可以跑满达到1G，这种情况下很容易触发EPOLLOUT，则使用ET。
关于某些场景下ET模式比LT模式效率更好。




更新：

（1）ET模式由于需要循环读取直到EAGAIN或EWOULDBLOCK，所以文件描述符connfd必须是非阻塞的。否则可能读到缓冲区为空阻塞住了，就无法处理后续其他事件。比如，其他用户连接。因为你还一直阻塞在当前connfd的读取，相当于本线程全部阻塞在了这里。epoll不起作用了。

（2）由于LT会多次触发，所以不需while循环。而ET只触发一次，所以需要。

FreeeLinux
关注
专栏目录
【Redis】IO多路复用 及 Select、Poll、Epoll、NIO
火火的博客
12-17 2227
文章目录文件事件处理器【I/O多路复用程序】的实现文件事件的处理器连接应答处理器：命令请求处理器：命令回复处理器一次完整的客户端与服务器链接示例 文件事件处理器 Redis开发了一个文件事件处理器，文件事件处理器使用I/O多路复用（multiplexing）程序来同时监听多个套接字， 并根据套接字目前执行的任务来为套接字关联不同的事件处理器。 当被监听的套接字准备好执行 连接应答（accept）、读取（read）、写入（write）、关闭（close）等操作时， 与操作相对应的文件事件就会产生，此时，文件事
IO多路复用---select详解及示例
weixin_46566893的博客
11-23 1634
一、IO多路复用 I/O复用使得程序能同时监听多个文件描述符，这使得程序的性能得到了很大程度的提高。 Linux下实现I/O复用的系统调用主要有select、poll、epoll。（这里注意：epoll是Linux系统所特有的） 二、select系统调用 select系统调用的用途：在一段时间内，监听文件描述符上的可读、可写、和异常时间的发生。本文主要介绍select系统调用API。 三、select API及主要函数说明 #include<sys/select.h> int select(in
linux基础——linux下多路IO复用接口之select/poll
千里之行，始于足下
08-23 1263
函数select和poll用于IO复用，它们都是监视一个或多个文件描述符集合，可以进行IO操作的时候就返回。 一、函数select() select允许内核等待多个事件中的任何一个发生，并且只要有一个或多个事件发生或者经历了一段指定的时间后才唤醒它。 函数原形如下： #include #include #include #include int select(
epoll读写事件触发的条件
回头太难
10-13 7657
先上个人理解： EPOLLIN（读事件） EPOLLOUT（写事件） 以下触发条件只要满足一点即可。 LT模式： EPOLLIN触发条件： 处于可读状态。 从不可读状态变为可读状态。 EPOLLOUT触发条件: 处于可写状态。 从不可写状态变为可写状态。 说白了，LT模式就是能读的时候就可读，能写的时候就可写。这并不是废话。 什么叫可读状态？什么叫不可读状态？ 一个水杯里有水...
epoll学习之路
蜜汁程序员的博客
09-18 617
        Socket 服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接...
IO多路复用(select、poll、epoll)
最新发布
坚定目标，超越自我
08-28 1033
准备阶段应用程序创建三个fd_set结构（readfds, writefds, exceptfds），用于表示要监视的读、写和异常事件的文件描述符集合。使用FD_SET()宏将需要监视的文件描述符添加到相应的fd_set中。调用select应用程序调用select函数，传入最大文件描述符值+1、三个fd_set和超时时间。select将fd_set从用户空间拷贝到内核空间。内核处理内核遍历所有fd_set中的文件描述符，检查它们的状态。如果没有就绪的文件描述符且未超时，进程会被阻塞。
TCP协议+IO多路复用 --- select，poll，epoll分析
本末实验室
09-08 2116
select、poll、epoll select，poll，epoll都是IO多路复用的机制。I/O多路复用就是通过一种机制，一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己...
图解IO多路复用模型之select、poll、epoll
weixin_73240939的博客
12-10 711
在之前的文章《如何不使用任何模型裸建服务器》（详情见上篇文章）中，我们最终使用了多线程来解决多客户端连接问题。Linux下，一般默认为一个线程占有8M的线程栈空间，那么如果有1024*8个连接，就需要8G的线程栈空间，显然具有高额的资源开销。在连接数巨大的时候，epoll的红黑树数据结构可以快速地实现节点的改查。包括相应事件发生的时候，内核也能迅速地查找到相应的节点并且进行后续操作。数据结构直接建立在内核中，无需将存储文件描述符集合和监听事件的数据结构实例反复复制进入内核中。没有连接数量大小的限制。
IO多路复用模式（Epoll、Poll、 Select）
后而来者
08-12 220
IO多路复用模式（Epoll、Poll、 Select） IO多路复用就是通过一种机制，一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select,poll,epoll本质上都是同步I/O,因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步IO的实现会负责把数据从内核拷贝到用户空间。 查看man手册 man pagenum function //查看对应的函数原型， pagenum 为页数， function
IO多路复用之select_poll_epoll详解1
08-04
IO多路复用通过系统调用如select、poll、epoll等，让程序可以监控多个文件描述符（通常包括网络套接字）。当其中任一描述符准备好进行读写操作时，系统会通知程序。这种机制在处理多个客户端连接时非常有效，避免了...
IO多路复用-Select、Poll、Epoll
青龙小码农
06-09 364
IO - 同步、异步、阻塞、非阻塞 5种IO模型（前面4中都属于同步）： blocking IO - 阻塞IO nonblocking IO - 非阻塞IO IO multiplexing - IO多路复用 signal driven IO - 信号驱动IO asynchronous IO - 异步IO 一次网络IO读操作会涉及两个系统对象： (1) 用户进程(线程)Process；(2)内核对象kernel，两个处理阶段，IO模型的异同点就是区分在这两个系统对象、两个处理阶段的不同上。 1 同步I
IO多路复用之epoll全面总结(必看篇)
09-15
在Linux系统中，epoll是针对IO多路复用的一种高效实现，尤其适用于大规模并发连接的场景。以下是关于epoll的详细总结： 1. **基本概念** - **epoll** 是在Linux 2.6内核引入的，是对早期的`select`和`poll`函数的...
tcpdump的基本用法之过滤表达式
热门推荐
FreeeLinux's blog
11-25 1万+
上篇博客写了tcpdump选项的用法， 这篇博客我们来看一下过滤表达式。 过滤表达式的man手册：man pcap-filter tcpdump在使用过滤表达式时，如有用了shell的通配符，需要用单引号引起来。 情形1：只抓udp的包 #tcpdump -i eth0 -c 10 'udp' 情形2：只想查看源机器和目的机器的包 # tcpdump
高性能大并发服务器架构
FreeeLinux's blog
11-24 7689
一个典型的服务器结构 主要由三部分组成 网络I/O+服务器高性能编程技术+数据库 一：网络I/O 网络I/O方面，linux下面使用epoll，windows上面有IOCP，其他平台还有kqueue，dev/poll等机制。 二：服务器及数据库的负载均衡 1.数据库 数据库可能会有以下几点需要解决： 1.超出数据库连接数     假
利用backtrace函数打印函数调用栈
FreeeLinux's blog
10-24 4740
我们一般打印函数调用栈可以选择GDB的backtrace命令，简写bt命令都可以。这里有一个新的方法，那就是利用backtrace函数打印，不过还要加上backtrace_symbols()函数。 int backtrace(void **buffer, int size) 该函数用于获取当前线程的调用堆栈,获取的信息将会被存放在buffer中,它是一个指针列表。参数 size 用来指
tcpdump的基本用法之选项
FreeeLinux's blog
11-25 4410
tcpdump基本用法 需要在root用户下使用，非root用户可用sudo。 tcpdump -i eth1 -nn -X port 8080 -c 1 -i：i 是interface的含义，是指我们有义务告诉tcpdump希望它去监听哪一个网卡。用ifconfig可以看到，一般不是eth0就是eth1。 -nn：是当tcpdump遇到协议号或端口号时，不要将这些号码转换成对
多进程、共享内存的网络聊天室
FreeeLinux's blog
02-08 2189
好久没写网络聊天室了，去年暑假可以说写了一暑假，最近复习这些，又因为我一直偏向于多线程，就用多进程复习一下。下面给出昨天写的基于多进程、共享内存的网络聊天室代码。每个进程负责一个连接，多个进程之间仅共享读，不共享写，因此无需信号量来同步。分配的一段内存中，以数组的方式，分配给每个client一段buffer，每个clilent对应的buffer的索引就是connfd。当一个子进程收到客户端数据后，通
Linux网络编程之多进程模型编程与一个使用进程池实现的CGI服务器
FreeeLinux's blog
08-29 2183
一：什么是多进程模型 多进程模型是服务器在接收到大量高并发客户端访问时，通过创建多个子进程来与客户端进行通信。单进程阻塞在read()系统调用的时候，会导致服务器无法响应到其他的连接请求。这时可以通过fork()函数创建出多个子进程来处理业务，而主进程继续循环accept()其他客户连接，子进程实施具体的通信细节。 二：fork函数详解 NAME        fork - create
网络编程定时器一：使用升序链表
FreeeLinux's blog
02-05 1917
之前一直对定时器这块不熟，今天来练练手。首先我们来看实现定时器的第一种方式，升序链表。网络编程中应用层的定时器是很有必要的，这可以让服务端主动关闭时间很久的非活跃连接。另外一种解决方案是TCP的keepalive，但它只能检测真正的死连接，即客端主机断电，或者网线被拔掉这种情况。如果客端连接上，但什么都不做，keepalive是毫无办法的，它只能一定时间后不断的向客户端发送心跳包。定时器通常至少要包
一个简单线程池的实现 --C语言
FreeeLinux's blog
09-18 1810
本文的代码实现了一个简单的线程池，并利用C/S模型将客户端所发送的数据进行简单的计算。 一：什么是线程池   我是这么理解的，池是计算机科学中一种典型的机制，如STL里面的内存池，数据库连接池，还有进程池或线程池。这些池建立的目的都是为了避免频繁系统调用所带来的开销。我们这样想，如果我们事先转备好一大块所需要的内存，或者线程，以后我们要用到时就直接拿来用就好了。不够的话再执行其他解决方案。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值