reactor线程模型 reactor线程模型案例代码

ja网络io模型有几种

#BIO---Blocking IO

reactor线程模型 reactor线程模型案例代码

reactor线程模型 reactor线程模型案例代码

- 每个socket一个线程，读写时线程处于阻塞状态。

优点：实现简单

缺点：无法满足高并发，高接入的需求

- 不使用线程池的BIO模型，除了无法满足高并发需求外，由于需要为每个请求创建一个线程，还可能因为接入大量不活跃连接而耗尽资源。

- 使用线程池的BIO模型，虽然控制了线程数量，但由于其本质上读写仍是阻塞的，仍无法满足高并发需求。

#NIO---Non-Blocking IO（非阻塞IO）

##非阻塞IO和多路复用

非阻塞IO和多路复用实际上是两个不用的概念，由于两者通常结合在一起使用，因此两者往往被混为一谈。下面我将试着分清这两个概念：

###非阻塞IO

与BIO相对应，非阻塞IO的读写方法无论是否有数据都立即返回，因此可以通过轮询方式来实现，但轮询方式的效率并不比BIO有显著提高，因为每个连接仍然需要占用一个线程。下面是轮询方式实现的IO模式图：

###多路复用

- 多路复用结合非阻塞IO能够明显提高IO的效率，这也是Ja1.4把非阻塞IO和多路复用同时发布的原因。

- 多路复用的核心是多路复用器(Selector)，它是需要作系统底层支持的，简单的说，就是进程把多个socket和它们关心的（比如连接请求或数据已准备好）都注册在多路复用器上，作系统会在发生时通知多路复用器，这样进程就可以通过多路复用器知道在那个socket上发生了什么时间，从而进行对应的处理。

- 多路复用的优点在于只需要一个线程监测（阻塞或轮询方式均可）多路选择器的状态，只有在有需要发生时才会真正的创建线程进行处理，因此更适合高并发多接入的应用环境。

- 在Linux系统下，多路复用的底层实现是epoll方法，与select/poll的顺序扫描不同，epoll采用效率更高的驱动方式，而且epoll方式并没有socket个数限制。

##BIO和NIO的比较

- BIO适用于连接长期保持的应用，比如一个复杂系统中模块之间通过长连接来进行通信。

- NIO加多路复用的模式更适合短连接、高并发、多接入的情形，比如网络。

##NIO网络编程的常用接口

##Reactor模式

Reactor模式用于解决分发处理的问题，Handler把自己的channel和关注的注册到Selector中，当对应的发生在自己的channel上时，对应的handler就会得到通知并进行处理。

- 单线程的Reactor

消息的分发、读写、处理都在一个线程中处理，是Reactor最简单的实现方式，如果消息的处理需要较长时间，会影响效率。

```ja

//Reactor类，负责分发并调用对应的handler

class Reactor implements Runnable {

final SocketChannel serverSocket;

//Reactor初始化

Reactor(int port) throws IOException {

selector = Selector.open();

serverSocket = SocketChannel.open();

serverSocket.socket().bind(new InetSocketAddress(port));

SelectionKey sk = serverSocket.register(selector, SelectionKey.OP_ACCEPT);

sk.attach(new Acceptor()); //attach callback object, Acceptor

}//分发消息并调用对应的handler

public void run() {

try {

while (!Thread.interrupted()) {

selector.select();

Set selected = selector.selectedKeys();

Iterator it = selected.iterator();

while (it.hasNext(pool.execute(new Processer()); //使用线程pool异步执行))

dispatch((SelectionKey)(it.next()); //Reactor负责dispatch收到的

selected.clear();

}} catch (IOException ex) { / ... / }

}void dispatch(SelectionKey k) {

if (r != null)

r.run();

}//Acceptor也是一个handler，负责创建socket并把新建的socket也注册到selector中

public void run() {

try {

SocketChannel c = serverSocket.accept();

if (c != null)

}catch(IOException ex) { / ... / }

}//Concrete Handler：用于收发和处理消息。

//在当前的实现中，使用Runnable接口作为每个具体Handler的统一接口

//如果在处理时需要参数和返回值，也可以为Handler另外声明一个统一接口来代替Runnable接口

final class Handler implements Runnable {

final SocketChannel socket;

final SelectionKey sk;

ByteBuffer input = ByteBuffer.allocate(MAXIN);

ByteBuffer output = ByteBuffer.allocate(MAXOUT);

static final int READING = 0, SENDING = 1;

int state = READING;

socket = c; c.configureBlocking(false);

sk = socket.register(sel, 0);

sk.attach(this); //将Handler作为callback对象

sk.interestOps(SelectionKey.OP_READ); //第二步,接收Read

sel.wakeup();

}boolean inputIsComplete() { / ... / }

boolean outputIsComplete() { / ... / }

void process() { / ... / }

public void run() {

try {

if (state == READING) read();

else if (state == SENDING) send();

} catch (IOException ex) { / ... / }

}void read() throws IOException {

socket.read(input);

process();

state = SENDING;

sk.interestOps(SelectionKey.OP_WRITE); //第三步,接收write

void send() throws IOException {

socket.write(output);

if (outputIsComplete()) sk.cancel(); //write完就结束了, 关闭select key

//我们可以用State-Object pattern来更优雅的实现

class Handler { // ...

public void run() { // initial state is reader

socket.read(input);

process();

sk.attach(new Sender()); //状态迁移, Read后变成write, 用Sender作为新的callback对象

sk.interest(SelectionKey.OP_WRITE);

sk.selector().wakeup();

class Sender implements Runnable {

public void run(){ // ...

socket.write(output);

if (outputIsComplete()) sk.cancel();

}```

- 多线程Reacotr

处理消息过程放在其他线程中执行

```ja

class Handler implements Runnable {

// uses util.concurrent thread提示：“创建平面”对象是一种刚体，在模拟作中，它用作固定的无限平面。通常会将其用于地面或桌面等较大的平面对象的模拟。 pool

static PooledExecutor pool = new PooledExecutor(...);

// ...

synchronized void read() { // ...

socket.read(input);

state = PROCESSING;

synchronized void processAndHandOff() {

process();

state = SENDING; // or rebind attachment

}class Processer implements Runnable {

public void run() { processAndHandOff(); }

```

- 使用多个selector

mainReactor只负责处理accept并创建socket，多个subReactor负责处理读写请求

```ja

Selector[] selectors; //subReactors, 一个selector代表一个subReactor

class Acceptor { // ...

Socke2. 分离器等待作完成的同时，作系统利用并行的内核线程执行实际的读作，并将结果数据存入用户自定义缓冲区，通知分离器读作完成。t connection = serverSocket.accept(); //主selector负责accept

if (connection != null)

new Handler(selectors[next], connection); //选个subReactor去负责接收到的connection

if (++next == selectors.length) next = 0;

```

#AIO

AIO是真正的异步IO，它于JDK1.7时引入，它和NIO的区别在于：

- NIO仍然需要一个线程阻塞在select方法上，AIO则不需要

- NIO得到数据准备好的消息以后，仍然需要自己把消息到用户空间，AIO则是通过作系统的支持把数据异步到用户空间以后再给应用进程发出信号。

使用性能模型有哪几种

很简单，通常是在Req中带上一个sequence(序列号)，同时保证同一个连接中sequence即可，在发送req之前，把sequence和callback的关系存在 map/dict 中。服务端在返回resp时回传sequence，这样客户端在收到resp报文时先解析出sequence，从 map/dict 获取响应请求的callback，然后callback.success(data)即可。

1.IO复用技术

IO复用是一种机制，简单说就是IO的到来、读写、异常等情况都有内核帮你了，应用程序只需要处理那些内核通知你的IO句柄即可，这种机制的前提是即使建立数万连接，某时刻可读写的fd数量只占总连接量的很小的比例，因此借助于内核驱动机制，就可以实现单线程的数万Socket的管理。

举个栗子：

一个大工厂很多车间，之前必须每个车间有个值班人员，per house per woker的模式，大部分情况下车间是没有异常情况的，但是为了保证万无一失，仍然需要一名。

后来引入了报警系统，视频音频等信息都实时传输到中控室，从而1名或数名就可以完成整个厂区的，大大提高效率。

IO复用就不多说了，并没有什么太多复杂之处，目前热门的epoll就是其中的悍将，至于epoll的一些详细的机制可以自行查询不再赘述了。

2.处理模型

网络设计模式中，如何处理各种I/O是其非常重要的一部分，Reactor 和Proactor两种处理模型应运而生，可以使用同步I/O实现Reactor模型，使用异步I/O实现Proactor模型。

Reactor处理模型

Reactor模型是同步I/O处理的一种常见模型，其核心思想：将关注的I/O注册到多路复用器上，一旦有I/O触发，将分发到处理器中，执行就绪I/O对应的处理函数中。

模型中有三个重要的组件：

多路复用器：由作系统提供接口，Linux提供的I/O复用接口有select、poll、epoll

分离器：将多路复用器返回的就绪分发到处理器中

处理器：处理就绪事轻量级，专注于网络，不如ACE那么臃肿庞大，只提供了简单的网络API的封装，线程池，内存池，递归锁等均需要自己实现；件处理函数

典型的Reactor模型类图结构：

Reactor 类结构中包含有的主要角色：

Handle：标示文件描述符

Event Demultiplexer：对作移动互联网面临的问题是网络不稳定是常态、弱网络是常态、流量敏感、电量敏感，因此二进制协议显然是更好的选择。系统内核实现I/O复用接口的封装等待发生发生

Event Handler：处理接口

Event Handler A/B：实现应用程序所提供的特定处理逻辑

3.并发模式

其中包括半同步/半异步模式、半同步/半反应堆模式、半同步/半反应堆模式改进版、Follower/Leader模式。

3dmax怎么创建真实的布料？3damx制作写实布料怎么作？

new Handler(selector, c);

在3damx制作里面。有时候由于布料的特殊性质，使用常规建模方法制作这种模型相当困难，所以不少的小伙伴可能就会比较困恼！但是其实是可以使用reactor工具集可以简单地实现刚体、布料、柔软体和绳索等效果，使用动力学模拟原理编辑对象，效果非常逼真。具体是怎么作的呢？我们接下来一起来作创建！另外还提供了一系列的3damx课程学习，最为大家学习课程：3dmax2018超详细零基础教程~

Handler(Selector sel, SocketChannel c) throws IOException {

3dmax创建真实写实布料作步骤：

sk.interest(SelectionKey.OP_WRITE); //process完,开始等待write

（1）运行3dax2011，打开素材“书源文件.max”文件，该文件内包括一个桌面、一本书的模型，和一块绘有地图的布料。在本实例中，需要设置布料落到书上的效果。

（2）在默认状态下，reactor工具栏是不显示的，为了便于作，需要打开reactor工具栏。

（3）在reactor工具栏内单击“创建平面”按钮，在顶视图中创建“平面001”对象。

（4）确定“平面001”对象仍处于被选择状态，在reactor工具栏中单击“创建刚体”按钮，在视图中创建RBCollection001对象。

提示：“刚体”是一种作为刚体容器的reactor辅助对象。一旦在场景中添加了刚体，就可以将场景中的任何有效刚体添加到中，未添加到中的对象，将不会加入到模拟过程。

（5）选择RBCollection001对象，进入“修改”面板，在该面板“刚体属性”卷展板内的“刚体”显示窗内将显示加入到“刚体”中的对象。单击“拾取”按钮，在视图中拾取“书”对象。

（6）选择“书”对象，在reactor工具栏中单击“打开属性编辑器”按钮，打开“刚体属性”对话框，在“模拟几何体”卷展栏内选择“凹面网格”单选按钮。

提示：为了加快模拟速度，默认状态下，在使用动力学模拟时会使用几何体代替源对象，虽然这样会节省运算时间，但是效果会受到影响。选择“凹面网格”单选按钮后，将使用对象的实际网格进行模拟，效果更为逼真。

（7）现在影响布料的行体对象已经设置完毕了，接下来需要设置布料对象，首先为“布料”对象添加一个ReactorCloth修改器。

（8）取消“布料”对象的选择状态，并在视图中创建一个CLCollection001对象。

（9）选择CLCollection001对象，进入“修改”面板，在“属性”卷展栏内单击“拾取”按钮，在视图中单击“布料”对象，在Properties卷展栏内的显示窗会显示“布料”对象名称，该对象被加入“Cloth”。

注意：只有添加ReactorCloth修改器并被加入到Cloth中的对象，才能够被设置为布料进行模拟。

（10）在“Reactor实时预览”对话框中观察“布料”对象的动画效果。

（11）当对象到达合适位置时，在“Reactor实时预览”对话框的菜单栏执行“MAX”→“更新MAX”命令，使场景中的布料成为同样的状态。

提示：“更新MAX”命令用于在模拟中获取对象的位置和旋转，用于更新3dsMax中的对象，我们可以使画面停顿在某一帧，得到合适的布料形态。

（12）由于动力模拟的问题，“布料”对象会与刚体对象有一定的距离，在视图中移动“布料”对象，使其与刚体相适配。

（13）当前“布料”对象的面数数较少，这是为了加快模拟速度，当模拟完成后，可以为其添加“网格平滑”修改器，这样既保持了视觉效果，又不影响模拟速度。

（14）当前“布料”对象的大体形态已经完成了，为了使其具有更为丰富的细节，可以为其添加“编辑多边形”修改器。

（15）对“布料”对象的顶点进行编辑就完成了

作到这里基本上就完成了，虽然步骤相对来说有点多，但是比较仔细！希望能够帮助到你~其实使用reactor工具集能够创建出逼真的布料对象，并且作非常简便。大家都可以尝试着作起来~

如何调整reactor--epoll线程数量

先看看经典的C10K问题

默认线程数取决于主机系统devpoll.c：对dev/poll的封装;的核心数量。

Webflux将尝试使上述线程尽可能繁忙，因此，只要它们消耗了CPRunnable r = (Runnable)(k.attachment()); //调用之前注册的callback对象U的全部功能，分配的线程实际上并不重要。更多线程将只需要等待轮换使用CPU。

如果需要考虑性能，则可以采用多种方法来获得更好的性能，例如，通过使多个系统具有前端的负载均衡器或多个cpu内核，并尝试分析应用程序中花费的时间。

如何在linux下实现nt机制

Reactor：反应器定义一个接口，注册和删除关注的句柄、运行处理循环、等待就绪触发，分发到注册的回调函数。

libnt是一个基于触发的网络库，适用于windows、linux、bsd等多种平台，内部使用select、epoll、kqueue等系统调用管理机制。特点：

开放源码，代码相当精炼、易读；

跨平台，支持Windows、Linux、BSD和Mac OS；

支持多种I/O多路复用技术（epoll、poll、dev/poll、select和kqueue等），在不同的作系统下，做了多路复用模型的抽象，可以选择使用不同的模型，通过函数提供服务；

支持I/O，定时器和信号等；

采用Reactor模式；

二、源码组织结构

Libnt 的源代码虽然都在一层文件夹下面，但是其代码分类还是相当清晰的，主要可分为头文件、内部使用的头文件、辅助功能函数、日志、libnt框架、对系 统I/O多路复用机制的封装、信号管理、定时管理、缓冲区管理、基本数据结构和基于libnt的两个实用库等几个部分，有些部分可能就是一个源文件。

1// Normally also do first write now）头文件

主要就是nt.h：宏定义、接口函数声明，主要结构体nt的声明；

2）内部头文件

xxx-internal.h：内部数据结构和函数，对外不可见，以达到信息隐藏的目的；

3）libnt框架

nt.c：nt整体框架的代码实现；

4）对系统I/O多路复用机制的封装

epoll.c：对epoll的封装；

select.c：对select的封装；

kqueue.c：对kqueue的封装；

5）定时管理

min-heap.h：其实就是一个以时间作为key的小根堆结构；

用插件 GLU 3D 在3D MAX 中运算挺快的，不用专门的流体软件。6）信号管理

3D Max怎么做各种水的模型，杯子里的、水龙头流出来的、浴缸里的（有波纹），不胜感激！！

if (inputIsComplete()) {

3Dmax做水对于客户端而言，有3种报文类型：的方法还是用其他软件，叫realflow，它是的流体动力学模拟软件，效果很不错，而且作简单。生成水效果之后能直接导入到3Dmax并带动画。

final Selector selector;

如果实在要在3Dmax自带的软件功能里面做水，做水龙头、喷泉之类流动或者喷射的水要用粒子或者粒子流来做，里面的粒子类型变形球是可以用来模拟水的。如果做静态或者带波纹的水，可以用上面说的带空间扭曲的水来做。

realflow用这个插件 效果不错

浅析libnt

在I/O密集型的程序，采用并发方式可以提高CPU的使用率，可采用多进程和多线程两种方式实现并发。

libnt是一个轻量级的开源高性能网络库，基于驱动，跨平台支持WIN linux Mac 支持多种IO多路复用技术，支持 IO 定时器和信号等的统一调度，支持注册的优先级。memcache 使用libnt作为底层网络库。

Reactor 模式：

我们普通的函数调用 ，是程序调用某函数 ，函数执行中一直等待该函数执行完之后再继续执行下面的代码。Reactor 模式是一种驱动机制。和普通的函数调用不同的是这里的应用程序不是主动的调用某个API函数完成处理，而是恰恰相反，Reactor逆置了处理流程，应用程序需要提供相应的接口并注册到Reactor，如果相应的发生，Reactor将主动调用应用 注册的接口，这些函数是回调函数。开始用户会在相应的nt中设置回调函数和相应句柄并由libnt中的Reactor实例进行管理。

采用Reactor模式是编写高性能网络的必备技术之一：

优点：响应快，不会因为某个同步所阻塞，因为采用的是回调函数执行，虽然Reactor本身是同步的。

//Acceptor会在Reactor初始化时就注册到Selector中，用于接受connect请求采用Reactor框架本身与具体的处理没有关系，只负责处理与用户的交互，具有很高复用性。

可以扩展多个Reactor实例来实现多CPU的资源利用

因为采用了阻塞的select epoll等IO复用函数进行阻塞批量的句柄，所以在到来时的处理逻辑，也就是回调函数不会阻塞住，而是非阻塞的执行。

应用场景：

1.初始化libnt的实例也就是struct nt_base结构体也就是对应的Reactor模型在libnt中的实体

struct nt_base base = nt_init();

2.用户初始化所要注册的 根据不同的，网络中主要包括 定时，IO，信号，libnt中使用宏方便用户根据不同的调用与名称相匹配的函数，但是内部全部都是调用一个借口nt_set(),参数中对于所有时间都会有一个函数指针用于用户注册回调函数，一个句柄（对于IO就是文件描述符，信号就是信号的编号，对于定时不用设置）

3.将本身的基本信息设置好之后要和Reactor的实例也就是和某一个nt_base 进行联系，因为可能存在//上面 的实现用Handler来同时处理Read和Write, 所以里面出现状态判断多个nt_base 实例

4.基本信息设置完成之后，调用nt_add 函数将通过Reactor实例也就是struct_base的统一接口找到性能的IO复用函数注册到其中，包括设置超时时间。对于定时，libnt使用一个小根堆管理，key为超时时间，对于IO和信号，将该放到等待双向链表中，

5.进入无限循环等待就绪，以epoll为例，每次循环前，libnt都会检查定时中最小的超时时间tv,根据tv设置epoll的等待时间，以便后面及时处理超时，当epoll超时返回后就将超时添加到就绪队列如果是正确返回就不用添加超时，之后同样直接依次遍历就绪队列执行相应的回调函数处理逻辑。此处可以看出是同步处理逻辑的。（IO已经在epoll_wait中添加进了就绪队列了)

IO和timer的统一：

因为系统提供的IO机制像select或者epoll_wait 都允许程序制定一个的等待时间，也称作超时时间timeout，即使没有IO发生，也能保证能在timeout时间到达时候返回。

根据所有timer的最小超时来设置系统IO的timeout时间，当系统IO返回时候再激活所有继续的timer就可以了，这样就能将timer完美的融合到系统的IO机制中去了。这是Reactor 和Proactor模式中处理Timer最经典的方法了。

libnt支持多线程：

libnt代码本身不支持多线程，因为源代码没有同步机制。

但是可以采用消息通知机制来支持多线程:

1.抢占：当一个线程正在执行的时候，此时主线程来了一个任务此时立即抢占执行主线程的任务，此时好处是任务可以立即得到处理，但是你必须处理好切换的问题，过多的切换也会为CPU带来效率问题。

2.消息通知机制:当主进程有一个任务需要处理的时候会发送一个消息通知你去执行任务，此时当前进程还是执行自己的任务，在自己的任务执行完后，查看消息说通知有一个任务，再去处理任务，但是通知消息不是立即查看的，没有很好的实时性。

3.消息通知+同步层 ：有个折中的处理方式，就是中间增减一个任务队列，这个任务队列是所有线程都可以看到的，每个线程都将新任务扔到这个队列中并且发送一个字符来通知，得到通知的当前线程只是取出其中的一个任务。当然，对于这个任务的作都是同步的，也就是每一个线程作要加锁，这就是一个加锁的队列。

在什么情况下变频器输出端要接电抗器，接电搞器的作用是什么？

int next = 0;

对于屏蔽电缆150米 非屏蔽电缆200米范围之外就需要加输出电抗器。

2、降低/dt对电机绝缘的影响；

3、扼制电缆容性电流效应// Optionally try first read now。

我们公司一般现场电缆距离超过100米，都加输出电抗器。

变频器对其它设备有干扰的时候一般会接电抗器，电机噪音大有public synchronized void run() { ...时也会

ja与mysql是nio还是bio

驱动，高性能;

Ja中的IO方式主要分为3种：BIO（同步阻塞）、NIO（同步非阻塞）和AIO（异步非阻塞）。

BIO

同步阻塞模式。在JDK1.4以前，使用Ja建立网络连接时，只能采用BIO方式，在端启动一个Socket，然后使用accept等待客户端请求，对于每一个请求，使用一个线程来进行处理用户请求。线程的大部1 Select、Poll与Epoll分时间都在等待请求的到来和IO作，利用率很低。而且线程的开销比较大，数量有限，因此同时能处理的连接数也很低。

TODONIO

BIO模式中，是“一个Socket一个线程”；而在NIO中则是使用单个或少量的线程来轮询Socket，当发现Socket上有请求时，才为请求分配线程。因此是“一个请求一个线程”。

具体实现就是把Socket通过Channel注册到Selector，使用一个线程在Selector中轮询，发现Channel有读写的，就可以分配给其他线程来处理（通常使用线程池）。

AIO

从JDK7开始支持AIO模式。通过AsynchronousSocketChannel中注册回调函数来处理业务逻辑。当IO作完成以后，回调函数会被调用。如果传入AsynchronousChannelGroup，可以绑定线程池来处理。

关于JDK的实现，Windows平台基于IOCP实现AIO，Linux只有eppoll模拟实现了AIO。

附：关于IO经常提到Reactor/ Proactor模式。

这两个模式中都有两个角色：多路分离器(Event Demultiplexer)和处理器(Event Handler)。分离器负责对IO，并通知处理器；处理器负责对IO内容进行处理，完成对应的业务。

二者的异，以读作为例（写作类似）。

Reactor中实现读：

1. 注册读就绪和相应的处理器。

2. 分离器等待。

3. 到来，激活分离器，分离器调用对应的处理器。

4. 处理器完成IO读作，处理读到的数据，注册新的，然后返还控制权。

Proactor中实现读：

1. 注册读完成和相应的处理器（包括缓冲区地址）。

3. 分离器呼唤处理器。

4. 处理器处理用户自定义缓冲区中的数据，然后启动一个新的异步作，并将控制权返回分离器。

更多问题可以问远标教育中心的技术咨询。

IO模型及select，poll，epoll和kqueue的区别

static final int PROCESSING = 3;

Select

}}

select本质上是通过设置或者检查存放fd标志位的数据结构来进行下一步处理。这样所带来的缺点是：

1 单个进程可监视的fd数量被限制

2 需要维护一个用来存放大量fd的数据结构，这样会使得用户空间和内核空间在传递该结构时开销大

3 对socket进行扫描时是线性扫描

Poll

poll本质上和select没有区别，它将用户传入的数组拷贝到内核空间，然后查询每个fd对应的设备状态，如果设备就绪则在设备等待队列中加入一项并继续遍历，如果遍历完所有fd后没有发现就绪设备，则挂起当前进程，直到设备就绪或者主动超时，被唤醒后它又要再次遍历fd。这个过程经历了多次无谓的遍历。

它没有连接数的限制，原因是它是基于链表来存储的，但是同样有一个缺点：大量的fd的数组被整体于用户态和内核地址空间之间，而不管这样的是不是有意义。

poll还有一个特点是“水平触发”，如果报告了fd后，没有被处理，那么下次poll时会再次报告该fd。

Epoll

epoll支持水平触发和边缘触发，的特点在于边缘触发，它只告诉进程哪些fd刚刚变为就需态，并且只会通知一次。

在前面说到的问题上，epoll使用mmap减少开销。

还有一个特点是，epoll使用“”的就绪通知方式，通过epoll_ctl注册fd，一旦该fd就绪，内核就会采用类似callback的回调机制来激活该fd，epoll_wait便可以收到通知

注：水平触发（ll-triggered）——只要满足条件，就触发一个(只要有数据没有被获取，内核就不断通知你)；边缘触发（edge-triggered）——每当状态变化时，触发一个。

2 性能比较

由于博主并没有提供测试的机器参数，以及测试程序代码，所以这个性能测试只能够算是一个补充吧，对于epoll在大量fd情况下优势的直观展示。

表格左侧是描述符的大小，右侧分别表示1s对poll和epoll的调用次数，也就是性能瓶颈。

从上表可以看出当fd数量较少的时候poll略优于epoll，但是当fd增大到某个阈值时，poll性能急剧下降。而epoll始终保持的稳定的性能。

3 使用

当同事需要保持很多的长连接，而且连接的开关很频繁时，就能够发挥epoll的优势了。这里与模型其实已经有些交集了。

同时需要保持很多的长连接，而且连接的开关很频繁，效的模型是非阻塞、异步IO模型。而且不要用select/poll，这两个API的有着O(N)的时间复杂度。在Linux用epoll，BSD用kqueue，Windows用IOCP，或者用libnt封装的统一接口（对于不同平台libnt实现时采用各个平台特有的API），这些平台特有的API时间复杂度为O(1)。

然而在非阻塞，异步I/O模型下的编程是非常痛苦的。由于I/O作不再阻塞，报文的解析需要小心翼翼，并且需要亲自管理维护每个链接的状态。并且为了充分利用CPU，还应结合线程池，避免在轮询线程中处理业务逻辑。

但这种模型的效率是极高的。以知名的nginx为例，可以轻松应付上千万的空连接+少量活动链接，每个连接连接仅需要几K的内核缓冲区，想要应付更多的空连接，只需简单的增加内存（数据来源为淘宝一位工程师的一次技术讲座，并未实测）。这使得DDoS攻击者的成本大大增加，这种模型攻击者只能将的带宽全部占用，才能达到目的，而两方的投入是不成比例的。

注：长连接——连接后始终不断开，然后进行报文发送和接受class Acceptor implements Runnable { // inner；短链接——每一次通讯都建立连接，通讯完成即断开连接，下次通讯再建立连接。

select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写