网络I/O与Select、Poll、Epoll（下篇）

在实现利用Select组件实现网络通信的前提下，再来看Poll和Epoll就简单多了。

首先Poll的数据结构如下：

struct pollfd {
    int fd;
    short events;
    short revents;
};

events 表示监测的事件，revents表示返回的事件结果。

比如一个客户端进行连接，所监测的fd为listenfd，监测的事件为POLLIN，通过poll函数进行返回，返回事件结果存储在revents中，在这里对poll函数不做详解。

同样Epoll的数据结构如下：

struct epoll_event {
    __poll_t events;
    __u64 data;
} EPOLL_PACKED;

epoll的实现主要由三个函数：

epoll_create（）
epoll_ctl(ADD, DEL, MOD)
epoll_wait（）

为了方便调试，下面代码段把select、poll、epoll的实现全部包含了，如下：

#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#include <sys/poll.h>
#include <sys/epoll.h>


//#include <pthread.h>

#define MAXLNE  4096

#define POLL_SIZE	1024

//8m * 4G = 128 , 512
//C10k

#if 0
void *client_routine(void *arg)   //
{

	int connfd = *(int *)arg;

	char buff[MAXLNE];

	while (1)
	{

		int n = recv(connfd, buff, MAXLNE, 0);
		if (n > 0)
		{
			buff[n] = '\0';
			printf("recv msg from client: %s\n", buff);

			send(connfd, buff, n, 0);
		}
		else if (n == 0)
		{
			close(connfd);
			break;
		}

	}

	return NULL;
}
#endif


int main(int argc, char **argv)
{
	int listenfd, connfd, n;
	struct sockaddr_in servaddr;
	char buff[MAXLNE];

	if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
	{
		printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
		return 0;
	}

	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(888);

	if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)
	{
		printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
		return 0;
	}

	if (listen(listenfd, 10) == -1)
	{
		printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
		return 0;
	}
#if 0
	struct sockaddr_in client;
	socklen_t len = sizeof(client);
	if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1)
	{
		printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
		return 0;
	}

	printf("========waiting for client's request========\n");
	while (1)
	{

		n = recv(connfd, buff, MAXLNE, 0);
		if (n > 0)
		{
			buff[n] = '\0';
			printf("recv msg from client: %s\n", buff);

			send(connfd, buff, n, 0);
		}
		else if (n == 0)
		{
			close(connfd);
		}

		//close(connfd);
	}

//一请求一线程写法
#elif 0

	while (1)
	{

		struct sockaddr_in client;
		socklen_t len = sizeof(client);
		if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1)
		{
			printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
			return 0;
		}

		pthread_t threadid;
		pthread_create(&threadid, NULL, client_routine, (void*)&connfd);

	}

//select 写法
#elif 0
	fd_set rfds, rset, wfds, wset;

	FD_ZERO(&rfds);
	FD_SET(listenfd, &rfds);

	FD_ZERO(&wfds);

	int max_fd = listenfd;

	while (1)
	{

		rset = rfds;
		wset = wfds;

		int nready = select(max_fd+1, &rset, &wset, NULL, NULL);
		printf("nready is: %d\n", nready);

		if (FD_ISSET(listenfd, &rset))
		{
			struct sockaddr_in client;
			socklen_t len = sizeof(client);
			if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1)
			{
				printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
				return 0;
			}

			printf("listenfd is: %d, connfd is :%d\n", listenfd,connfd);

			FD_SET(connfd, &rfds);
			if (connfd > max_fd) max_fd = connfd;
			if (--nready == 0) continue;
		}

		int i = 0;
		for (i = listenfd+1; i <= max_fd; i ++)
		{
			if (FD_ISSET(i, &rset))
			{
				n = recv(i, buff, MAXLNE, 0);
				if (n > 0)
				{
					buff[n] = '\0';
					printf("recv msg from client: %s\n", buff);
					FD_CLR(i, &rfds);
					FD_SET(i, &wfds);
				}
				else if (n == 0)
				{
					close(i);
					FD_CLR(i, &rfds);
					printf("disconnect\n");
				}
				if (--nready == 0) break;
			}
			else if (FD_ISSET(i, &wset))
			{
				send(i, buff, n, 0);
				FD_CLR(i, &wfds);
				FD_SET(i, &rfds);
				if (--nready == 0) break;
			}
		}
	}

// poll写法
#elif 1

	struct pollfd fds[POLL_SIZE] = {0};
	fds[0].fd = listenfd;
	fds[0].events = POLLIN;

	int max_fd = listenfd;
	int i = 0;
	for (i = 1; i < POLL_SIZE; i ++)
	{
		fds[i].fd = -1;
	}

	while (1)
	{
		int nready = poll(fds, max_fd+1, -1);
		printf("nready is :%d\n", nready);


		if (fds[0].revents & POLLIN)
		{
			struct sockaddr_in client;
			socklen_t len = sizeof(client);
			if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1)
			{
				printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
				return 0;
			}

			printf("listenfd is: %d, connfd is :%d\n", listenfd,connfd);
			fds[connfd].fd = connfd;
			fds[connfd].events = POLLIN;

			if (connfd > max_fd) max_fd = connfd;
			if (--nready == 0) continue;
		}

		for (i = listenfd+1; i <= max_fd; i ++)
		{
			printf("revents: %d\n", fds[i].revents);
			if (fds[i].revents & POLLIN)
			{
				printf("recv!\n");
				n = recv(i, buff, MAXLNE, 0);
				if (n > 0)
				{
					buff[n] = '\0';
					printf("recv msg from client: %s\n", buff);

					fds[i].events = POLLOUT;
				}
				else if (n == 0)     //
				{
					close(i);
					fds[i].fd = -1;
				}
				if (--nready == 0) break;
			}
			else if (fds[i].revents & POLLOUT)
			{
				printf("send!\n");
				send(i, buff, n, 0);
				fds[i].events = POLLIN;
				if (--nready == 0) break;
			}
		}
	}

//epoll 写法
#elif 0

	// epoll_create
	// epoll_ctl(ADD, DEL, MOD)
	// epoll_wait

	int epfd = epoll_create(1); //int size

	struct epoll_event events[POLL_SIZE] = {0};
	struct epoll_event ev;

	ev.events = EPOLLIN;
	ev.data.fd = listenfd;

	epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

	while (1)
	{

		int nready = epoll_wait(epfd, events, POLL_SIZE, 5);
		//printf("clientfd is :%d\n", events[0].data.fd);
		if (nready == -1)
		{
			continue;
		}

		int i = 0;
		for (i = 0; i < nready; i ++)
		{

			int clientfd =  events[i].data.fd;
			printf("listenfd is: %d, clientfd is :%d\n", listenfd,clientfd);
			if (clientfd == listenfd)
			{

				struct sockaddr_in client;
				socklen_t len = sizeof(client);
				if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1)
				{
					printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
					return 0;
				}

				printf("accept\n");
				ev.events = EPOLLIN;
				ev.data.fd = connfd;
				printf("connfd is :%d\n", connfd);
				epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
			}
			else if (events[i].events & EPOLLIN)
			{

				n = recv(clientfd, buff, MAXLNE, 0);
				if (n > 0)
				{
					buff[n] = '\0';
					printf("recv msg from client: %s\n", buff);

					ev.events = EPOLLOUT;
				}
				else if (n == 0)  
				{

					ev.events = EPOLLIN;
					ev.data.fd = clientfd;

					epoll_ctl(epfd, EPOLL_CTL_DEL, clientfd, &ev);

					close(clientfd);

				}

			}
			else if (events[i].events & EPOLLOUT)
			{
				send(clientfd, buff, n, 0);
				ev.events = EPOLLIN;
			}

		}

	}


#endif

	close(listenfd);
	return 0;
}

总结一下：

select 和 poll原理差不多，select通过一个fdset来实现，这个fdset其实是一个bit序列，通过对该bit序列上的位进行置位或者清零，在select函数监测到就绪的fd时，判断fdset中对应的位置是否置位进行相应的操作。这样的话，select就能实现同时监测多个fd，达到实现多个客户端通信的效果。

poll其实也是一样，只是poll通过把fd和事件（event）结合起来，poll函数不断监测所有fd的event，如果触发，通过判断revents来进行相应的操作。同样可以实现多个客户端通信的效果。

实际上，select或者poll都受限于fd的数量，而且对fd轮询的方式在大量fd的情况下效率是比较低下的。至于epoll，后面文章会接触到更多的应用，到时候再讲为什么epoll在大量客户端的情况下会显得更高效。