皮皮网

1.C++网络编程I/O 多路复用之epoll(一)
2.浅谈树形结构的内核内核特性和应用（上）:多叉树，红黑树，红黑红黑堆，树源树Trie树，内核内核B树，红黑红黑B+树...
3.带你手撕红黑树的树源树guaguale源码插入与删除（图文详解）
4.深入理解Linux的epoll机制
5.红黑树的原理和应用场景
6.当 Android 程序员面试时遇到手写红黑树，“ 我 ”冷汗流了一地

C++网络编程I/O 多路复用之epoll(一)

       å‰è¨€

       ä¼¼ä¹Žæˆ‘总是这样，宁愿持续学习，也不愿意总结。就好像高中，总是跟着老师听课，但不乐于自己把老师讲的知识串起来，进行总结。这种想法其实是在自己骗自己，听了等于学会那是不可能的，不愿意总结就是因为那块知识学的还不熟练，回忆起来觉得麻烦。同时的我也知道最舒服的时候是老师讲课后题的时候，我都会，别的同学在费劲的听讲，而我可以做别的时候，也正因为这样的自大，在有些时候丢失了一些细节的关注，这是我对我中学时期学习的反思。这也是为什么说，人最爽的时刻是知识输出，把自己在脑子里建构的房子，拿出来，展示给大家，那简直就像刚刚练好了凌波微步，就开始输出魅力。 抗拒总结，但有时候越抗拒的事情，越有做它的道理，梳理完epoll之后，对于我自己而言，脑子里会有一个更加清晰地脉络。

回顾上文

       ä¸Šæ–‡æˆ‘们知道了poll对select的改进和发展，但是仍遗留下来一些问题：

       åŒ…含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间。

       å†…核态要通过遍历线性扫描是否有就绪的文件描述符。

       ç”¨æˆ·æ€éœ€è¦é€šè¿‡éåŽ†èŽ·å–就绪事件的文件描述符。

       é’ˆå¯¹è¿™ä¸‰æ¡ï¼Œepoll进行了解决：

       å†…核通过一个事件表直接管理用户感兴趣的所有事件，这样内核中保存一份文件描述符集合，epoll需要使用一个额外的文件描述符，来唯一标识内核中的事件表，这个文件描述符使用epoll_create函数来创建。每次调用无需用户重新传入，只需告诉内核修改(epoll_ctl)的部分即可。

       æ•ˆçŽ‡æå‡ï¼Œå†…核不再通过轮询遍历的方式找到就绪的文件描述符，而是通过异步 IO 事件唤醒，其实就是采用回调函数方式，如果某个文件描述符已就绪，它会主动调用回调函数，该回调函数将文件描述符放入到就绪链表中。

       å†…核仅会将IO事件就绪的文件描述符返回(epoll_wait)给用户，这样，用户无需遍历整个文件描述符集合。 如果仔细分析这些改进，其实都在函数中有体现，透过函数的内容现象看到底层内核的运行本质，这样的映射学习，有利于我们理解和明晰。也是在学习epoll的过程中，我体会到了异步的妙用，为什么要有回调函数、函数指针这样的东西存在。

epoll

       å†…核检测epoll传递的fd集合,内核内核 是以红黑树的形式遍历的,红黑树用于管理所有的文件描述符fd，就绪链表用于保存有事件发生的文件描述符。

epoll_create函数

       åˆ›å»ºä¸€æ£µç›‘听红黑树

#include <sys/epoll.h>int epoll_create(int size);参数: size: 创建的红黑树的监听节点数量（仅供内核参考，没意义）。返回值;>0: 文件描述符, 操作epoll树的根节点,来唯一标识内核中的事件表。epoll_ctl函数

       å¯¹ç›‘听红黑树进行管理,操作epoll的内核事件表: 添加节点, 删除节点, 修改已有的节点属性。

#include<sys/epoll.h>int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

       å‚数：

       epfd：epoll_create的返回值, 通过这个值就可以找到红黑树。

       op：指定操作类型，操作类型有三种

       EPOLL_CTL_ADD 添加fd到监听红黑树epfd，往事件表中注册事件

       EPOLL_CTL_MOD 修改epfd上的注册事件属性

       EPOLL_CTL_DEL 从红黑树epfd删除注册事件，取消监听

       fd：待监听的 fd

       struct epoll_event *event：指定监听文件描述符的什么事件，本质是个结构体，还是个结构体套结联合体 返回值：成功 0； 失败： -1 ，设置errno。

epoll_event的定义struct epoll_event{ uint_t events; //Epoll监听的事件epoll_data_t data;//用于存储用户数据};

       uint_t events的常用取值：

       EPOLLIN：描述符处于可读状态

       EPOLLOUT：描述符处于可写状态

       EPOLLET：将epoll event通知模式设置成edge triggered

       EPOLLONESHOT：第一次进行通知，之后不再监测

       EPOLLHUP：本端描述符产生一个挂断事件，默认监测事件

       EPOLLRDHUP：对端描述符产生一个挂断事件

       EPOLLPRI：由带外数据触发

       EPOLLERR：描述符产生错误时触发，默认检测事件

epoll_data_t的定义typedef union epoll_data{ int fd;//简单，一般用这个记录监听的文件描述符void*ptr;//复杂，指向用户自定义数据，写到reactor(反应堆)模型的时候会用到这个uint_t u;uint_t u;}epoll_data_t;示例

       è¿™å—的赋值有些复杂，加个示例一看就明白了。

struct epoll_event temp;temp.events=EPOLLIN; /*默认是LT水平触发 */temp.data.fd=lfd;ret=epoll_ctl(epfd,EPOLL_CTL_ADD,lfd,&temp);epoll_wait函数

       é˜»å¡žç›‘听

#include<sys/epoll.h>int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

       å‚数：

       epfd：epoll_create的返回值, 通过这个值就可以找到红黑树。

       events：传出参数, 以数组形式返回就绪事件的文件描述符集合结构体struct epoll_event

       maxevents：定义的events数组的大小

       é˜»å¡žæ—¶é—´ï¼Œå°±æ˜¯ç”¨æˆ·æ‹¿ä¸€æ¬¡æ•°æ®å¯ä»¥ç­‰å¾…的时间：

       -1: 一直阻塞，直到有事件就绪

       0： 不阻塞，立即返回，轮询

       >0: 超时时间（毫秒），如果期间有就绪就返回，否则直到超时 返回值：返回就绪的文件描述符个数，失败时返回-1并设置errno。

       ç”¨æˆ·éåŽ†å°±ç»ªäº‹ä»¶çš„时候，就是靠函数返回值控制边界，从传出参数events中拿信息。

LT模式与ET模式

       è¿™ä¸¤ä¸ªè¯æ±‡æ¥è‡ªç”µå­¦æœ¯è¯­ï¼Œå¯ä»¥å°† fd 上有数据认为是高电平，没有数据认为是低电平，将 fd 可写认为是高电平，fd 不可写认为是低电平。那么水平模式的触发条件是状态处于高电平，而边缘模式的触发条件是新来一次电信号将当前状态变为高电平。 select 和 poll 都只能工作在相对低效的LT（水平触发）模式，而epoll 虽然默认也是工作在LT模式下，但是它还可以工作在更高效的ET（边缘触发）模式下。并且 epoll 还支持 EPOLLONESHOT事件。该事件能进一步减少可读、可写和异常事件被触发的次数。

LT（水平触发）模式（默认）

       LT(level triggered)是默认的工作方式，并且同时支持block（阻塞）和no-block （非阻塞） socket。当epoll_wait检测到有事件就绪并将此事件返回给用户后，可以不立即处理该事件（因为后面还会被触发）。这样，当应用程序下一次调用epoll_wait时，epoll_wait还会再次触发，返回此事件，直到该事件被处理。 比如，使用此种模式，当数据可读的时候，EPOLLIN事件到来，不read的话，这个EPOLLIN事件会不停的通知，epoll_wait()将会一直返回就绪事件，然后可以对这个就绪的fd进行IO操作。如果没有完全处理数据，再次调用epoll_wait()还会把此事件当就绪事件返回。进行read（读操作后），才会停止通知。一个事件只要有，就会一直触发

ET（边缘触发）模式

       å…³é”®è¯å°±ä¸€å¥è¯ï¼Œåªæœ‰ä¸€ä¸ªäº‹ä»¶ä»Žæ— åˆ°æœ‰æ‰ä¼šè§¦å‘。 采用ET模式时，当epoll_waitepoll_wait检测到其上有事件发生并将此事件通知应用程序后，应用程序必须立即处理该事件，因为后续的epoll_wait调用将不再向应用程序通知这一事件。 比如，如果EPOLL事件到来，不论是否read，只通知一次。 可见ET模式在很大程度上降低了同一个epoll事件被重复触发的次数，因此ET模式效率比LT模式高 注意：每个使用ET模式的文件描述符都应该是非阻塞的，如果描述符是阻塞的，那么读或写操作将会因没有后续事件而一直处于阻塞状态(饥渴状态)。归结成这个问题：为何epoll的ET模式文件要设置为非阻塞？这段话我也理解了很久，其实弄明白阻塞 IO和非阻塞 IO就自然懂得了。

总结

       å†™ä¸åŠ¨äº†ï¼Œå…¶å®žä¸Šé¢è¿™äº›ä¸œè¥¿ï¼Œç½‘上一搜一大堆，但我希望以一种有条理的方式顺下来吧，在我的脑子里过一遍，有什么东西都会明晰一些。接下来会介绍阻塞 IO和非阻塞 IO，然后是epoll服务器的编写思路，然后尽可能的讲解一些为什么和踩坑点，最后提出自己的一些思考吧。

原文：/post/

浅谈树形结构的特性和应用（上）:多叉树，红黑树，红黑红黑堆，树源树Trie树，内核内核B树，红黑红黑B+树...

       深入探讨树形结构的树源树特性与应用

       树形结构是数据元素之间呈现树状关系的数据结构。它具有继承性，内核内核每个节点最多有两个分支，红黑红黑以此构建多层次的树源树数据组织。这一结构广泛应用于文件系统、组织架构表示、XML/HTML数据、类的继承关系及决策场景等。

       多叉树允许一个父节点拥有多个子节点，简化了描述复杂数据关系的需求，支持决策过程中的多种选择。

       二叉树每个节点最多两个分支，适用于“非黑即白”的决策场景。在编译器的语法树构造、表达式求值、IPv4路由表存储等领域有广泛应用。

       二叉查找树（Binary Search Tree）具有节点左子树小于父节点、右子树大于父节点的特性，实现快速的查找、定位，适用于排序、查找场景。

       红黑树是一种平衡二叉查找树，通过约束确保树的高度稳定，提供高效、稳定的增删改查操作，广泛应用于容器、Linux内核调度器、epoll机制等。

       堆是一种特殊的数据结构，具有“大顶堆”或“小顶堆”的特性，适用于排序、TopK查找、合并有序文件、优先队列等。

       Trie树（前缀树）利用字符串的公共前缀进行匹配，适用于关键词匹配、最长公共前缀查找、命令自动补全等场景，但内存占用较大。

       B树与B+树是数据库中常用的多级索引结构，分别适用于MongoDB和MySQL，B树索引与数据共存，B+树索引独立于数据，数据存储在叶子节点，提供高效的数据访问。

       总结，树形结构通过层次化组织数据，支持高效的数据查找、排序与管理。傅里叶变换梅林 源码不同类型的树结构根据特定需求优化性能，适用于多样化的应用领域。

带你手撕红黑树的插入与删除（图文详解）

       红黑树是具有颜色属性的二叉查找树，其关键性质确保树的平衡，允许插入、删除和查找操作在最坏情况下的时间复杂度为O(log n)。这些性质由四个约束组成，确保了路径长度不会超过最短路径的两倍。在表示中，所有节点都有两个子节点，即使有些是空叶子节点。插入和删除操作会破坏红黑树的性质，需要通过少量的颜色变更和树旋转来恢复。

       在插入操作中，首先将新节点以二叉查找树的方式加入并标记为红色。接下来，根据新节点与其父节点和祖父节点的颜色关系，进行相应的调整以维持红黑树性质。如果插入节点的父节点为红色，则可能需要调整以避免出现两个连续的红色节点。这种调整通常包括颜色变更和树旋转。

       红黑树在Linux内核中有多种应用，包括进程调度、内存管理、nginx的共享内存、epoll机制和sk_buff数据结构。它们提供了高效的数据存储和检索方式，是Linux系统中不可或缺的组件。

       删除操作涉及找到替代节点以覆盖目标节点，并在完成后删除替代节点。目标节点的右子树中的最小节点通常被选作替代节点。在删除之前，对替代节点进行命名以简化后续操作。根据替代节点的颜色和兄弟节点的颜色关系，有九种不同的删除情形。每种情形都涉及“借”操作，即利用红色节点来维持树的平衡。

       总的来说，红黑树通过其独特的颜色属性和一系列约束，确保了操作的高效性。无论是插入、删除还是查找操作，都能在保证树的平衡的前提下，实现快速的数据处理。红黑树在操作系统内核、数据库系统和分布式系统中都有广泛的应用，是计算机科学领域中一种非常实用的数据结构。

深入理解Linux的epoll机制

       在Linux系统之中有一个核心武器：epoll池，在高并发的，高吞吐的IO系统中常常见到epoll的身影。

IO多路复用

       在Go里最核心的是Goroutine，也就是所谓的协程，协程最妙的一个实现就是异步的代码长的跟同步代码一样。比如在Go中，网络IO的read，write看似都是同步代码，其实底下都是异步调用，一般流程是：

write(/*IO参数*/)请求入队等待完成后台loop程序发送网络请求唤醒业务方

       Go配合协程在网络IO上实现了异步流程的同步代码化。核心就是用epoll池来管理网络fd。

       实现形式上，手机是 mobile 源码后台的程序只需要1个就可以负责管理多个fd句柄，负责应对所有的业务方的IO请求。这种一对多的IO模式我们就叫做IO多路复用。

       多路是指？多个业务方（句柄）并发下来的IO。

       复用是指？复用这一个后台处理程序。

       站在IO系统设计人员的角度，业务方咱们没办法提要求，因为业务是上帝，只有你服从的份，他们要创建多个fd，那么你就需要负责这些fd的处理，并且最好还要并发起来。

       业务方没法提要求，那么只能要求后台loop程序了！

       要求什么呢？快！快！快！这就是最核心的要求，处理一定要快，要给每一个fd通道最快的感受，要让每一个fd觉得，你只在给他一个人跑腿。

       那有人又问了，那我一个IO请求（比如write）对应一个线程来处理，这样所有的IO不都并发了吗？是可以，但是有瓶颈，线程数一旦多了，性能是反倒会差的。

       这里不再对比多线程和IO多路复用实现高并发之间的区别，详细的可以去了解下nginx和redis高并发的秘密。

最朴实的实现方式？

       我不用任何其他系统调用，能否实现IO多路复用？

       可以的。那么写个for循环，每次都尝试IO一下，读/写到了就处理，读/写不到就sleep下。这样我们不就实现了1对多的IO多路复用嘛。

whileTrue:foreach句柄数组{ read/write(fd,/*参数*/)}sleep(1s)

       慢着，有个问题，上面的程序可能会被卡死在第三行，使得整个系统不得运行，为什么？

       默认情况下，我们没有加任何参数create出的句柄是阻塞类型的。我们读数据的时候，如果数据还没准备好，是会需要等待的，当我们写数据的时候，如果还没准备好，默认也会卡住等待。所以，在上面伪代码第三行是可能被直接卡死，而导致整个线程都得到不到运行。

       举个例子，现在有，，这3个句柄，现在读写都没有准备好，只要read/write(,/*参数*/)就会被卡住，但，这两个句柄都准备好了，查看net软件源码那遍历句柄数组，，的时候就会卡死在前面，后面，则得不到运行。这不符合我们的预期，因为我们IO多路复用的loop线程是公共服务，不能因为一个fd就直接瘫痪。

       那这个问题怎么解决？

       只需要把fd都设置成非阻塞模式。这样read/write的时候，如果数据没准备好，返回EAGIN的错误即可，不会卡住线程，从而整个系统就运转起来了。比如上面句柄还未就绪，那么read/write(,/*参数*/)不会阻塞，只会报个EAGIN的错误，这种错误需要特殊处理，然后loop线程可以继续执行，的读写。

       以上就是最朴实的IO多路复用的实现了。但是好像在生产环境没见过这种IO多路复用的实现？为什么？

       因为还不够高级。for循环每次要定期sleep1s，这个会导致吞吐能力极差，因为很可能在刚好要sleep的时候，所有的fd都准备好IO数据，而这个时候却要硬生生的等待1s，可想而知。。。

       那有同学又要质疑了，那for循环里面就不sleep嘛，这样不就能及时处理了吗？

       及时是及时了，但是CPU估计要跑飞了。不加sleep，那在没有fd需要处理的时候，估计CPU都要跑到%了。这个也是无法接受的。

       纠结了，那sleep吞吐不行，不sleep浪费cpu，怎么办？

       这种情况用户态很难有所作为，只能求助内核来提供机制协助来。因为内核才能及时的管理这些通知和调度。

       我们再梳理下IO多路复用的需求和原理。IO多路复用就是1个线程处理多个fd的模式。我们的要求是：这个“1”就要尽可能的快，避免一切无效工作，要把所有的时间都用在处理句柄的IO上，不能有任何空转，sleep的时间浪费。

       有没有一种工具，我们把一箩筐的fd放到里面，只要有一个fd能够读写数据，后台loop线程就要立马唤醒，全部马力跑起来。其他时间要把cpu让出去。

       能做到吗？能，这种需求只能内核提供机制满足你。

这事Linux内核必须要给个说法？

       是高通源码地址的，想要不用sleep这种辣眼睛的实现，Linux内核必须出手了，毕竟IO的处理都是内核之中，数据好没好内核最清楚。

       内核一口气提供了3种工具select，poll，epoll。

       为什么有3种？

       历史不断改进，矬->较矬->卧槽、高效的演变而已。

       Linux还有其他方式可以实现IO多路复用吗？

       好像没有了！

       这3种到底是做啥的？

       这3种都能够管理fd的可读可写事件，在所有fd不可读不可写无所事事的时候，可以阻塞线程，切走cpu。fd有情况的时候，都要线程能够要能被唤醒。

       而这三种方式以epoll池的效率最高。为什么效率最高？

       其实很简单，这里不详说，其实无非就是epoll做的无用功最少，select和poll或多或少都要多余的拷贝，盲猜（遍历才知道）fd，所以效率自然就低了。

       举个例子，以select和epoll来对比举例，池子里管理了个句柄，loop线程被唤醒的时候，select都是蒙的，都不知道这个fd里谁IO准备好了。这种情况怎么办？只能遍历这个fd，一个个测试。假如只有一个句柄准备好了，那相当于做了1千多倍的无效功。

       epoll则不同，从epoll_wait醒来的时候就能精确的拿到就绪的fd数组，不需要任何测试，拿到的就是要处理的。

epoll池原理

       下面我们看一下epoll池的使用和原理。

epoll涉及的系统调用

       epoll的使用非常简单，只有下面3个系统调用。

epoll_createepollctlepollwait

       就这？是的，就这么简单。

       epollcreate负责创建一个池子，一个监控和管理句柄fd的池子；

       epollctl负责管理这个池子里的fd增、删、改；

       epollwait就是负责打盹的，让出CPU调度，但是只要有“事”，立马会从这里唤醒；

epoll高效的原理

       Linux下，epoll一直被吹爆，作为高并发IO实现的秘密武器。其中原理其实非常朴实：epoll的实现几乎没有做任何无效功。我们从使用的角度切入来一步步分析下。

       首先，epoll的第一步是创建一个池子。这个使用epoll_create来做：

       原型：

intepoll_create(intsize);

       示例：

epollfd=epoll_create();if(epollfd==-1){ perror("epoll_create");exit(EXIT_FAILURE);}

       这个池子对我们来说是黑盒，这个黑盒是用来装fd的，我们暂不纠结其中细节。我们拿到了一个epollfd，这个epollfd就能唯一代表这个epoll池。

       然后，我们就要往这个epoll池里放fd了，这就要用到epoll_ctl了

       原型：

intepoll_ctl(intepfd,intop,intfd,structepoll_event*event);

       示例：

if(epoll_ctl(epollfd,EPOLL_CTL_ADD,,&ev)==-1){ perror("epoll_ctl:listen_sock");exit(EXIT_FAILURE);}

       上面，我们就把句柄放到这个池子里了，op（EPOLL_CTL_ADD）表明操作是增加、修改、删除，event结构体可以指定监听事件类型，可读、可写。

       第一个跟高效相关的问题来了，添加fd进池子也就算了，如果是修改、删除呢？怎么做到时间快？

       这里就涉及到你怎么管理fd的数据结构了。

       最常见的思路：用list，可以吗？功能上可以，但是性能上拉垮。list的结构来管理元素，时间复杂度都太高O(n)，每次要一次次遍历链表才能找到位置。池子越大，性能会越慢。

       那有简单高效的数据结构吗？

       有，红黑树。Linux内核对于epoll池的内部实现就是用红黑树的结构体来管理这些注册进程来的句柄fd。红黑树是一种平衡二叉树，时间复杂度为O(logn)，就算这个池子就算不断的增删改，也能保持非常稳定的查找性能。

       现在思考第二个高效的秘密：怎么才能保证数据准备好之后，立马感知呢？

       epoll_ctl这里会涉及到一点。秘密就是：回调的设置。在epoll_ctl的内部实现中，除了把句柄结构用红黑树管理，另一个核心步骤就是设置poll回调。

       思考来了：poll回调是什么？怎么设置？

       先说说file_operations->poll是什么？

       在fd篇说过，Linux设计成一切皆是文件的架构，这个不是说说而已，而是随处可见。实现一个文件系统的时候，就要实现这个文件调用，这个结构体用structfile_operations来表示。这个结构体有非常多的函数，我精简了一些，如下：

structfile_operations{ ssize_t(*read)(structfile*,char__user*,size_t,loff_t*);ssize_t(*write)(structfile*,constchar__user*,size_t,loff_t*);__poll_t(*poll)(structfile*,structpoll_table_struct*);int(*open)(structinode*,structfile*);int(*fsync)(structfile*,loff_t,loff_t,intdatasync);//....};

       你看到了read，write，open，fsync，poll等等，这些都是对文件的定制处理操作，对于文件的操作其实都是在这个框架内实现逻辑而已，比如ext2如果有对read/write做定制化，那么就会是ext2_read，ext2_write，ext4就会是ext4_read，ext4_write。在open具体“文件”的时候会赋值对应文件系统的file_operations给到file结构体。

       那我们很容易知道read是文件系统定制fd读的行为调用，write是文件系统定制fd写的行为调用，file_operations->poll呢？

       这个是定制监听事件的机制实现。通过poll机制让上层能直接告诉底层，我这个fd一旦读写就绪了，请底层硬件（比如网卡）回调的时候自动把这个fd相关的结构体放到指定队列中，并且唤醒操作系统。

       举个例子：网卡收发包其实走的异步流程，操作系统把数据丢到一个指定地点，网卡不断的从这个指定地点掏数据处理。请求响应通过中断回调来处理，中断一般拆分成两部分：硬中断和软中断。poll函数就是把这个软中断回来的路上再加点料，只要读写事件触发的时候，就会立马通知到上层，采用这种事件通知的形式就能把浪费的时间窗就完全消失了。

       划重点：这个poll事件回调机制则是epoll池高效最核心原理。

       划重点：epoll池管理的句柄只能是支持了file_operations->poll的文件fd。换句话说，如果一个“文件”所在的文件系统没有实现poll接口，那么就用不了epoll机制。

       第二个问题：poll怎么设置？

       在epoll_ctl下来的实现中，有一步是调用vfs_poll这个里面就会有个判断，如果fd所在的文件系统的file_operations实现了poll，那么就会直接调用，如果没有，那么就会报告响应的错误码。

staticinline__poll_tvfs_poll(structfile*file,structpoll_table_struct*pt){ if(unlikely(!file->f_op->poll))returnDEFAULT_POLLMASK;returnfile->f_op->poll(file,pt);}

       你肯定好奇poll调用里面究竟是实现了什么？

       总结概括来说：挂了个钩子，设置了唤醒的回调路径。epoll跟底层对接的回调函数是：ep_poll_callback，这个函数其实很简单，做两件事情：

       把事件就绪的fd对应的结构体放到一个特定的队列（就绪队列，readylist）；

       唤醒epoll，活来啦！

       当fd满足可读可写的时候就会经过层层回调，最终调用到这个回调函数，把对应fd的结构体放入就绪队列中，从而把epoll从epoll_wait出唤醒。

       这个对应结构体是什么？

       结构体叫做epitem，每个注册到epoll池的fd都会对应一个。

       就绪队列很高级吗？

       就绪队列就简单了，因为没有查找的需求了呀，只要是在就绪队列中的epitem，都是事件就绪的，必须处理的。所以就绪队列就是一个最简单的双指针链表。

       小结下：epoll之所以做到了高效，最关键的两点：

       内部管理fd使用了高效的红黑树结构管理，做到了增删改之后性能的优化和平衡；

       epoll池添加fd的时候，调用file_operations->poll，把这个fd就绪之后的回调路径安排好。通过事件通知的形式，做到最高效的运行；

       epoll池核心的两个数据结构：红黑树和就绪列表。红黑树是为了应对用户的增删改需求，就绪列表是fd事件就绪之后放置的特殊地点，epoll池只需要遍历这个就绪链表，就能给用户返回所有已经就绪的fd数组；

哪些fd可以用epoll来管理？

       再来思考另外一个问题：由于并不是所有的fd对应的文件系统都实现了poll接口，所以自然并不是所有的fd都可以放进epoll池，那么有哪些文件系统的file_operations实现了poll接口？

       首先说，类似ext2，ext4，xfs这种常规的文件系统是没有实现的，换句话说，这些你最常见的、真的是文件的文件系统反倒是用不了epoll机制的。

       那谁支持呢？

       最常见的就是网络套接字：socket。网络也是epoll池最常见的应用地点。Linux下万物皆文件，socket实现了一套socket_file_operations的逻辑（net/socket.c）：

staticconststructfile_operationssocket_file_ops={ .read_iter=sock_read_iter,.write_iter=sock_write_iter,.poll=sock_poll,//...};

       我们看到socket实现了poll调用，所以socketfd是天然可以放到epoll池管理的。

       还有吗？

       有的，其实Linux下还有两个很典型的fd，常常也会放到epoll池里。

       eventfd：eventfd实现非常简单，故名思义就是专门用来做事件通知用的。使用系统调用eventfd创建，这种文件fd无法传输数据，只用来传输事件，常常用于生产消费者模式的事件实现；

       timerfd：这是一种定时器fd，使用timerfd_create创建，到时间点触发可读事件；

       小结一下：

       ext2，ext4，xfs等这种真正的文件系统的fd，无法使用epoll管理；

       socketfd，eventfd，timerfd这些实现了poll调用的可以放到epoll池进行管理；

       其实，在Linux的模块划分中，eventfd，timerfd，epoll池都是文件系统的一种模块实现。

思考

       前面我们已经思考了很多知识点，有一些简单有趣的知识点，提示给读者朋友，这里只抛砖引玉。

       问题：单核CPU能实现并行吗？

       不行。

       问题：单线程能实现高并发吗？

       可以。

       问题：那并发和并行的区别是？

       一个看的是时间段内的执行情况，一个看的是时间时刻的执行情况。

       问题：单线程如何做到高并发？

       IO多路复用呗，今天讲的epoll池就是了。

       问题：单线程实现并发的有开源的例子吗？

       redis，nginx都是非常好的学习例子。当然还有我们Golang的runtime实现也尽显高并发的设计思想。

总结

       IO多路复用的原始实现很简单，就是一个1对多的服务模式，一个loop对应处理多个fd；

       IO多路复用想要做到真正的高效，必须要内核机制提供。因为IO的处理和完成是在内核，如果内核不帮忙，用户态的程序根本无法精确的抓到处理时机；

       fd记得要设置成非阻塞的哦，切记；

       epoll池通过高效的内部管理结构，并且结合操作系统提供的poll事件注册机制，实现了高效的fd事件管理，为高并发的IO处理提供了前提条件；

       epoll全名eventpoll，在Linux内核下以一个文件系统模块的形式实现，所以有人常说epoll其实本身就是文件系统也是对的；

       socketfd，eventfd，timerfd这三种”文件“fd实现了poll接口，所以网络fd，事件fd，定时器fd都可以使用epoll_ctl注册到池子里。我们最常见的就是网络fd的多路复用；

       ext2，ext4，xfs这种真正意义的文件系统反倒没有提供poll接口实现，所以不能用epoll池来管理其句柄。那文件就无法使用epoll机制了吗？不是的，有一个库叫做libaio，通过这个库我们可以间接的让文件使用epoll通知事件，以后详说，此处不表；

后记

       epoll池使用很简洁，但实现不简单。还是那句话，Linux内核帮你包圆了。

       今天并没有罗列源码实现，以很小的思考点为题展开，简单讲了一些epoll的思考，以后有机会可以分享下异步IO（aio）和epoll能产生什么火花？Golang是怎样使用epoll池的？敬请期待哦。

       原创不易，更多干货，关注：奇伢云存储

红黑树的原理和应用场景

       红黑树的原理和应用场景。

红黑树的原理和应用场景

       网为大家说一说红黑树的原理和应用场景的相关经验，接下来分享详细内容。

       红黑树（Red Black Tree）是一种平衡的排序二叉树，如图：

       所有的红黑树都满足如下性质：

每个节点要么是红色，要么是黑色的；根节点和叶子节点（即 NIL 空节点）一定是黑色；红色节点的父节点，或者子节点一定为黑色；对每个节点，从该节点到叶子节点的所有路径上，包含的黑节点数目相同。

       根据性质4，我们可以得出：从根节点到叶子节点的可能路径，最长不超过最短路径的两倍。

红黑树的主要应用场景：java8 hashmap 中链表转红黑树优势：时间复杂度从O(n) –> O(logn)，且自旋开销较其他树较低（不用整体平衡）。epoll 在内核中的实现，用红黑树管理 fd 文件描述符

       优势：

因为内核态需要维护一个长久存放 fd 的数据结构，而 fd 的变动十分频繁，且需要支持快速查询，所以红黑树很适合红黑树可以判断是否是重复的 fd

       3.Linux 进程调度 Completely Fair Scheduler，用红黑树管理进程控制块；nginx 中，用红黑树管理 timer 等 。

       以上网介绍的红黑树的原理和应用场景的具体内容，供大家参考操作。

当 Android 程序员面试时遇到手写红黑树，“ 我 ”冷汗流了一地

       红黑树是一种复杂的数据结构，它在二叉查找树的基础上增加了颜色属性，以保证树的平衡性，从而在插入和删除节点时保持查找效率稳定。本文通过分析红黑树的特性和等同的2-3-4树，以更易理解的方式介绍红黑树的基本概念和操作。

       红黑树的节点包含颜色属性，且满足以下条件：每个节点要么是红色，要么是黑色；根节点一定是黑色；每个叶子节点（NIL）都是黑色；如果一个节点是红色，则它的两个子节点都是黑色；从每个节点到其每个叶子节点的所有路径上包含相同数量的黑色节点。这保证了红黑树在插入和删除操作后的平衡性。

       红黑树的优势在于其稳定的查找效率，即使在频繁插入和删除节点后，红黑树的高度增长最多为 O(log n)，从而保证了 O(log n) 的查找时间复杂度。这一特性使得红黑树广泛应用于需要稳定查找效率的场景，例如 Linux 内核中的内存区域管理、Java8 中 HashMap 的实现等。

       红黑树与2-3-4树之间存在等同关系，后者是一种四阶的平衡树，其中每个节点可以包含最多四个元素。在实际应用中，2-3-4树的结构复杂性使得其在某些编程语言中实现不便，而红黑树作为一种简化形式，更容易理解和实现。通过将2-3-4树的节点与红黑树的子树对应，可以直观地理解两者之间的关系。

       在实现红黑树时，需要处理插入、删除操作以及颜色旋转等操作以维持红黑树的性质。这些操作旨在避免树的高度变化，从而保证树的平衡性。通过调整节点的颜色和执行旋转操作，可以在插入和删除节点后保持红黑树的性质，确保查找效率稳定。

       对于需要深入理解和掌握红黑树的读者，本文提供了一种基于2-3-4树的视角来理解红黑树的方法，有助于简化学习过程。同时，通过实际的代码实现和调试经验分享，加深对红黑树特性的理解。希望本文能为读者提供一个清晰、直观的路径，帮助他们更好地理解和应用红黑树。

内核基础设施分析(二)Maple Tree

       Linux 6.1内核引入了革命性的Maple Tree数据结构，旨在解决内存管理子系统中长期存在的锁竞争问题，特别是涉及页表和虚拟内存区域(VMA)的关键结构。Liam Howlett和Matthew Wilcox的创新设计目标是提高内存操作的效率，尤其是查找和修改VMA，减少对mmap_lock的依赖，从而缓解多线程应用中的锁争抢问题。

       目前，内核主要依赖基数树和红黑树，但Maple Tree作为一款针对现代CPU优化的RCU-safe range-based B树，其和的分支因子设计旨在减少缓存 misses，提高性能。它已被应用于vm_area_struct，包括增强的rbtree、VMA缓存和mm_struct中的VMA链接列表，旨在最终消除mmap_lock的竞争。

       一个具体的应用实例是find_vma函数，通过Maple Tree取代rbtree，展示了这一结构在实际操作中的优势。关于Maple Tree的更多技术细节和实现，可以从以下参考资料获取：lwn.net、lore.kernel.org、blogs.oracle.com、youtube.com以及new.qq.com等网站的相应文章和讨论。

       通过引入Maple Tree，Linux内核开发者正在寻求一种更高效、更线程友好的内存管理方式，以提升系统整体性能和用户体验。