到这里，我们需要整理一下之前学习的epoll模型，并根据之前的epoll模型，提出弊端，进而整理epoll反应堆模型，进一步深刻理解，这是因为epoll实在是太重要了。

复习之前的epoll的整体流程以及思路。

参考之前写的epoll的代码

第一步，socket，创建套接字。

int listenfd = Socket(AF_INET, SOCK_STREAM,0);

第二步，setsockopt 设定端口复用

int opt = 1;
Setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

第三步， bind函数，将socket和地址结构绑定

Bind(listenfd, (struct sockaddr *)&servaddr,sizeof(servaddr));

第四步，Listen 设置可以同时监听的最大的数量为1024

Listen(listenfd, 1024);

第五步，Epoll_create 创建一个红黑树结点,建议的节点>0

int epfd = Epoll_create(OPEN_MAX);

第六步，Epoll_ctl 先将listenfd添加到 epfd这个红黑树上，EPOLL_CTL_ADD表示是添加节点.EPOLLIN表示监听读事件

    struct epoll_event event;
    bzero(&event, sizeof(event));
    event.events = EPOLLIN; 
    event.data.fd = listenfd;
    //epoll_ct 函数的目的是给这颗红黑树上添加节点，删除节点，修改节点
    Epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd, &event);

第七步，epoll_wait,这时候就需要弄一个循环监听了, 使用 epoll_wait函数等待连接

while (1) {
        //epoll_wait返回值nready为满足监听的总个数。realevents是传出参数，传出满足监听条件的所有的结构体
        nready = epoll_wait(epfd, realevents, OPEN_MAX, -1);

}

第7.1步：

epoll_wait返回后，如果realevents 中的是listenfd，说明有客户端第一次连接过来，需要使用accpet去接受这个链接，生成clientfd ，

int clientfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddrlen);

然后将这个clientfd添加到红黑树上。

                Epoll_ctl(epfd, EPOLL_CTL_ADD, clientfd, &clientevent);

第7.2步：

epoll_wait返回后，如果realevents 中的是clientfd，那么说明客户端有发真正的数据过来，需要使用read 函数去读取这些数据，完成我们对于数据的处理，然后再使用write发给客户端

realreadnum = Read(socketfd, buf, MAXLINE);

//将读到的数据做处理，我们这里只是小写转大写。
for (int j = 0; j < realreadnum; ++j) {
        buf[j] = toupper(buf[j]);
}
Write(socketfd, buf, realreadnum);

这里会有问题，这是因为在网络环境下，环境是很复杂的，例如：客户端的 滑动窗口 已经满了

fix 方案：epoll 反应堆模型

接上述条件，因此在这里我们需要判断客户端是否能写，如果能写，也就是说：我们需要将 clientfd 的 “写事件” 加入到红黑树上。写完后，将 clientfd 的“写事件” 从红黑树上摘下。

还有一个问题，当我们接受的这些数据还没有处理的时候，我们不希望从 clientfd 再 “读取数据”，因此还需要将 clientfd 的“读事件” 从 红黑树上摘下，等待 给客户端 写数据完成后，再将 读取数据事件  添加回 红黑树上。

整个整理如下：

如果realevents中是clientfd--------> read 数据

-------->将clientfd 从红黑树上摘下（将clientfd 的 读事件通过epoll_del  从 红黑树上摘下），

-------->将clientfd 的写事件 通过epoll_ctl上添加到红黑树上

-------->当epoll_wait的返回时，如果返回中有 写事件 ，再使用write /send 发送数据给客户端

-------->当发送数据完成后，则将clientfd 的写事件从红黑树上摘下

-------->将clientfd 的读事件再次添加到红黑树上，从而形成循环

epoll反应堆模型的再次说明：

在epoll反应堆模型之前，我们需要使用到 epoll_event 中的 data 中的 fd来决定具体是那个连接

struct epoll_event
{
  uint32_t events;	/* Epoll events */
  epoll_data_t data;	/* User data variable */
} __EPOLL_PACKED;

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

在epoll反应堆的时候，我们需要使用到 epoll_event 中的 data 中的 ptr

因为ptr是一个万能指针，可以指向任何东西，因此一般使用的时候，会有一个struct，将相关的信息都放在这个struct中，且这个ptr就指向这个ptr，这样就能保存所有的信息，且会将 epoll_wait成立需要调用的方法，通过回调函数的形式添加到这个struct中，

实际上是多了个参数的使用：：   ET + NONBLOCK  轮询 + void *ptr

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <sys/types.h>         
#include <sys/socket.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/epoll.h>



#include "wrap.h"
#define MAXLINE 8192
#define SERV_PORT 8000
#define OPEN_MAX 5000

int main() {

	int ret = 0;

	//第一步，socket，创建套接字。On  success,  a  file  descriptor  for  the new socket is returned
	int listenfd = Socket(AF_INET, SOCK_STREAM,0);

	//第二步，setsockopt 设定端口复用,代码是固定的，当opt是1的时候，说明可以复用端口。 On success, zero is returned for the standard options.  On error, -1 is returned, and errno is set appropriately.

	int opt = 1;
	Setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

	//第三步， bind函数，将socket和地址结构绑定
	//int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
	struct sockaddr_in servaddr;
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

	Bind(listenfd, (struct sockaddr *)&servaddr,sizeof(servaddr));


	//第四步，设置可以同时监听的最大的数量为1024，如果改成5000会不会错呢？
	Listen(listenfd, 1024);
	//Listen(listenfd, OPEN_MAX);


	//第五步，创建一个红黑树结点,我们建议这个红黑树的节点为5000
	int epfd = Epoll_create(OPEN_MAX);

	//第六步，先将listenfd添加到 epfd这个红黑树上，EPOLL_CTL_ADD表示是添加节点.EPOLLIN表示监听读事件
	struct epoll_event event;
	bzero(&event, sizeof(event));
	event.events = EPOLLIN; 
	event.data.fd = listenfd;
	//epoll_ct 函数的目的是给这颗红黑树上添加节点，删除节点，修改节点
	Epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd, &event);

	//第七步，这时候就需要弄一个循环监听了, 使用 epoll_wait函数等待连接
	struct epoll_event realevents[OPEN_MAX];
	int nready = 0;
	while (1) {
		//epoll_wait返回值nready为满足监听的总个数。realevents是传出参数，传出满足监听条件的所有的结构体
		nready = epoll_wait(epfd, realevents, OPEN_MAX, -1);
		if (nready == -1) {
			perr_exit("epoll_wait error");
		}
		for (int i = 0; i < nready;++i) {
			if (!(realevents[i].events & EPOLLIN)) {
				//如果不是"读"事件, 继续循环
				continue;
			}
			int socketfd = realevents[i].data.fd;
			if (socketfd == listenfd) {
				//如果是listenfd 的读事件，说明有新的链接过来了，这时候要调用accpet
				struct sockaddr_in cliaddr;
				int cliaddrlen = sizeof(cliaddr);
				bzero(&cliaddr, cliaddrlen);
				printf("aaa\n");
				int clientfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddrlen);
				char str[INET_ADDRSTRLEN] = {0};//#define INET_ADDRSTRLEN 16
				printf("received from %s at PORT %d\n",
					inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
					ntohs(cliaddr.sin_port));

				//然后将connfd，添加到红黑树上
				struct epoll_event clientevent;
				bzero(&clientevent, sizeof(clientevent));
				clientevent.events = EPOLLIN;
				clientevent.data.fd = clientfd;
				Epoll_ctl(epfd, EPOLL_CTL_ADD, clientfd, &clientevent);

			}
			else {
				//如果不是listenfd，那么就是connectfd了，说明这时候客户端有东西写过来，我们要从客户端读取数据
				char buf[MAXLINE] = {0};
				int realreadnum;
				REREADPOINT:
				realreadnum = Read(socketfd, buf, MAXLINE);
				
				if (realreadnum == 0) {//在网络环境下，read函数返回0，说明是对端关闭了，也就是说，客户端关闭了
	//那么就应该关闭当前的connect端，并将该监听从 红黑树上 移除
					printf("read done\n");
					Epoll_ctl(epfd, EPOLL_CTL_DEL, socketfd, NULL);
					Close(socketfd);
				}
				else if (realreadnum == -1) {

					if (errno == EINTR) {
						//说明是被信号打断的，一般要重新read
						printf("信号打断\n");
						goto REREADPOINT;
					}
					else if (errno == EAGAIN || errno == EWOULDBLOCK)
					{
						printf(" WOULDBLOCK \n");
						//说明在打开文件的时候是使用的O_NONBLOCK方式打开的，但是没有读取到数据
						//当前代码是不会走到这里的，因为前面代码select的最后一个参数用的NULL，是阻塞的
						//一般在这里 也要重新读，但是这里有个问题，如果一直都读取不到，会不会死循环？
						goto REREADPOINT;
					}
					else if (errno == ECONNRESET) {
						//ECONNRESET 说明连接被重置了，因此要将该cfd关闭，并重新移除监听队列
						printf("read done\n");
						Epoll_ctl(epfd, EPOLL_CTL_DEL, socketfd, NULL);
						Close(socketfd);
					}
					else {
						//这就是真正的有问题了，注意这里不要exit程序，应该只是让打印log
						//不退出程序是因为，这时候还有其他的链接连上的
						perror("read num <0");
					}
				}
				else if (realreadnum > 0) {
					//真正的读取到了客户端发送过来的数据
					for (int j = 0; j < realreadnum; ++j) {
						buf[j] = toupper(buf[j]);
					}
					Write(socketfd, buf, realreadnum);
					Write(STDOUT_FILENO, buf, realreadnum);
				}
			}
		}
	}

	Close(listenfd);
	Close(epfd);
	return ret;
}