Netty源码解读(四)Netty与Reactor模式

转载 2015年07月07日 18:07:06

一:Netty、NIO、多线程?

时隔很久终于又更新了!之前一直迟迟未动也是因为积累不够,后面比较难下手。过年期间@李林锋hw发布了一个Netty5.0架构剖析和源码解读 ,看完也是收获不少。前面的文章我们分析了Netty的结构,这次咱们来分析最错综复杂的一部分-Netty中的多线程以及NIO的应用。

理清NIO与Netty的关系之前,我们必须先要来看看Reactor模式。Netty是一个典型的多线程的Reactor模式的使用,理解了这部分,在宏观上理解Netty的NIO及多线程部分就不会有什么困难了。

本篇文章依然针对Netty 3.7,不过因为也看过一点Netty 5的源码,所以会有一点介绍。

 

二:Reactor,反应堆还是核电站?

1、Reactor的由来

Reactor是一种广泛应用在服务器端开发的设计模式。Reactor中文大多译为“反应堆”,我当初接触这个概念的时候,就感觉很厉害,是不是它的原理就跟“核反应”差不多?后来才知道其实没有什么关系,从Reactor的兄弟“Proactor”(多译为前摄器)就能看得出来,这两个词的中文翻译其实都不是太好,不够形象。实际上,Reactor模式又有别名“Dispatcher”或者“Notifier”,我觉得这两个都更加能表明它的本质。

那么,Reactor模式究竟是个什么东西呢?这要从事件驱动的开发方式说起。我们知道,对于应用服务器,一个主要规律就是,CPU的处理速度是要远远快于IO速度的,如果CPU为了IO操作(例如从Socket读取一段数据)而阻塞显然是不划算的。好一点的方法是分为多进程或者线程去进行处理,但是这样会带来一些进程切换的开销,试想一个进程一个数据读了500ms,期间进程切换到它3次,但是CPU却什么都不能干,就这么切换走了,是不是也不划算?

这时先驱们找到了事件驱动,或者叫回调的方式,来完成这件事情。这种方式就是,应用业务向一个中间人注册一个回调(event handler),当IO就绪后,就这个中间人产生一个事件,并通知此handler进行处理。这种回调的方式,也体现了“好莱坞原则”(Hollywood principle)-“Don’t call us, we’ll call you”,在我们熟悉的IoC中也有用到。看来软件开发真是互通的!

好了,我们现在来看Reactor模式。在前面事件驱动的例子里有个问题:我们如何知道IO就绪这个事件,谁来充当这个中间人?Reactor模式的答案是:由一个不断等待和循环的单独进程(线程)来做这件事,它接受所有handler的注册,并负责先操作系统查询IO是否就绪,在就绪后就调用指定handler进行处理,这个角色的名字就叫做Reactor。

2、Reactor与NIO

Java中的NIO可以很好的和Reactor模式结合。关于NIO中的Reactor模式,我想没有什么资料能比Doug Lea大神(不知道Doug Lea?看看JDK集合包和并发包的作者吧)在《Scalable IO in Java》解释的更简洁和全面了。NIO中Reactor的核心是Selector,我写了一个简单的Reactor示例,这里我贴一个核心的Reactor的循环(这种循环结构又叫做EventLoop),剩余代码在这里

01 public void run() {
02     try {
03         while (!Thread.interrupted()) {
04             selector.select();
05             Set selected = selector.selectedKeys();
06             Iterator it = selected.iterator();
07             while (it.hasNext())
08                 dispatch((SelectionKey) (it.next()));
09             selected.clear();
10         }
11     } catch (IOException ex) { /* ... */
12     }
13 }

3、与Reactor相关的其他概念

前面提到了Proactor模式,这又是什么呢?简单来说,Reactor模式里,操作系统只负责通知IO就绪,具体的IO操作(例如读写)仍然是要在业务进程里阻塞的去做的,而Proactor模式则更进一步,由操作系统将IO操作执行好(例如读取,会将数据直接读到内存buffer中),而handler只负责处理自己的逻辑,真正做到了IO与程序处理异步执行。所以我们一般又说Reactor是同步IO,Proactor是异步IO。

关于阻塞和非阻塞、异步和非异步,以及UNIX底层的机制,大家可以看看这篇文章IO – 同步,异步,阻塞,非阻塞 (亡羊补牢篇),以及陶辉(《深入理解nginx》的作者)《高性能网络编程》的系列。

三:由Reactor出发来理解Netty

1、多线程下的Reactor

讲了一堆Reactor,我们回到Netty。在《Scalable IO in Java》中讲到了一种多线程下的Reactor模式。在这个模式里,mainReactor只有一个,负责响应client的连接请求,并建立连接,它使用一个NIO Selector;subReactor可以有一个或者多个,每个subReactor都会在一个独立线程中执行,并且维护一个独立的NIO Selector。

这样的好处很明显,因为subReactor也会执行一些比较耗时的IO操作,例如消息的读写,使用多个线程去执行,则更加有利于发挥CPU的运算能力,减少IO等待时间。

Multiple Reactors

2、Netty中的Reactor与NIO

好了,了解了多线程下的Reactor模式,我们来看看Netty吧(以下部分主要针对NIO,OIO部分更加简单一点,不重复介绍了)。Netty里对应mainReactor的角色叫做“Boss”,而对应subReactor的角色叫做”Worker”。Boss负责分配请求,Worker负责执行,好像也很贴切!以TCP的Server端为例,这两个对应的实现类分别为NioServerBossNioWorker(Server和Client的Worker没有区别,因为建立连接之后,双方就是对等的进行传输了)。

Netty 3.7中Reactor的EventLoop在AbstractNioSelector.run()中,它实现了Runnable接口。这个类是Netty NIO部分的核心。它的逻辑非常复杂,其中还包括一些对JDK Bug的处理(例如rebuildSelector),刚开始读的时候不需要深入那么细节。我精简了大部分代码,保留主干如下:

01 abstract class AbstractNioSelector implements NioSelector {
02  
03     //NIO Selector
04     protected volatile Selector selector;
05  
06     //内部任务队列
07     private final Queue taskQueue = new ConcurrentLinkedQueue();
08  
09     //selector循环
10     public void run() {
11         for (;;) {
12             try {
13                 //处理内部任务队列
14                 processTaskQueue();
15                 //处理selector事件对应逻辑
16                 process(selector);
17             } catch (Throwable t) {
18                 try {
19                     Thread.sleep(1000);
20                 } catch (InterruptedException e) {
21                     // Ignore.
22                 }
23             }
24         }
25     }
26  
27     private void processTaskQueue() {
28         for (;;) {
29             final Runnable task = taskQueue.poll();
30             if (task == null) {
31                 break;
32             }
33             task.run();
34         }
35     }
36  
37     protected abstract void process(Selector selector) throws IOException;

其中process是主要的处理事件的逻辑,例如在AbstractNioWorker中,处理逻辑如下:

01 protected void process(Selector selector) throws IOException {
02     Set selectedKeys = selector.selectedKeys();
03     if (selectedKeys.isEmpty()) {
04         return;
05     }
06     for (Iterator i = selectedKeys.iterator(); i.hasNext();) {
07         SelectionKey k = i.next();
08         i.remove();
09         try {
10             int readyOps = k.readyOps();
11             if ((readyOps & SelectionKey.OP_READ) != 0 || readyOps == 0) {
12                 if (!read(k)) {
13                     // Connection already closed - no need to handle write.
14                     continue;
15                 }
16             }
17             if ((readyOps & SelectionKey.OP_WRITE) != 0) {
18                 writeFromSelectorLoop(k);
19             }
20         } catch (CancelledKeyException e) {
21             close(k);
22         }
23  
24         if (cleanUpCancelledKeys()) {
25             break; // break the loop to avoid ConcurrentModificationException
26         }
27     }
28 }

这不就是第二部分提到的selector经典用法了么?

在4.0之后,作者觉得NioSelector这个叫法,以及区分NioBossNioWorker的做法稍微繁琐了点,干脆就将这些合并成了NioEventLoop,从此这两个角色就不做区分了。我倒是觉得新版本的会更优雅一点。

3、Netty中的多线程

下面我们来看Netty的多线程部分。一旦对应的Boss或者Worker启动,就会分配给它们一个线程去一直执行。对应的概念为BossPoolWorkerPool。对于每个NioServerSocketChannel,Boss的Reactor有一个线程,而Worker的线程数由Worker线程池大小决定,但是默认最大不会超过CPU核数*2,当然,这个参数可以通过NioServerSocketChannelFactory构造函数的参数来设置。

1 public NioServerSocketChannelFactory(
2         Executor bossExecutor, Executor workerExecutor,
3         int workerCount) {
4     this(bossExecutor, 1, workerExecutor, workerCount);
5 }

最后我们比较关心一个问题,我们之前ChannlePipeline中的ChannleHandler是在哪个线程执行的呢?答案是在Worker线程里执行的,并且会阻塞Worker的EventLoop。例如,在NioWorker中,读取消息完毕之后,会触发MessageReceived事件,这会使得Pipeline中的handler都得到执行。

01 protected boolean read(SelectionKey k) {
02     ....
03  
04     if (readBytes > 0) {
05         // Fire the event.
06         fireMessageReceived(channel, buffer);
07     }
08  
09     return true;
10 }

可以看到,对于处理事件较长的业务,并不太适合直接放到ChannelHandler中执行。那么怎么处理呢?我们在Handler部分会进行介绍。

最后附上项目github地址,欢迎交流:https://github.com/code4craft/netty-learning

参考资料:

题图来自:http://www.worldindustrialreporter.com/france-gives-green-light-to-tokamak-fusion-reactor/

原创文章,转载请注明: 转载自并发编程网 – ifeve.com

相关文章推荐

Netty源码解读(四)Netty与Reactor模式

一:Netty、NIO、多线程? 时隔很久终于又更新了!之前一直迟迟未动也是因为积累不够,后面比较难下手。过年期间李林锋发布了一个Netty5.0架构剖析和源码解读 ,看完也是收获不少。前面的文...

Netty源码解读(四)Netty与Reactor模式

一:Netty、NIO、多线程? 时隔很久终于又更新了!之前一直迟迟未动也是因为积累不够,后面比较难下手。前面的文章我们分析了Netty的结构,这次咱们来分析最错综复杂的一部分-Netty中的多...

【Netty源码分析】Reactor线程模型

1. 背景1.1. Java线程模型的演进1.1.1. 单线程时间回到十几年前,那时主流的CPU都还是单核(除了商用高性能的小机),CPU的核心频率是机器最重要的指标之一。在Java领域当时比较流行的...

Netty学习之旅----源码分析netty服务端初始化流程(Reactor主从模式实现)

本文以Netty服务端启动实例代码为视角,将Netty服务端的启动流程用序列图进行展开描述,清晰的剖析了Netty服务器端口绑定、主从Reactor线程模型、业务Handler编排细节。...

Netty学习之旅------线程模型前置篇Reactor反应堆设计模式实现(基于java.nio)

本文提供Reactor线程模型的代码实现,基于java.nio包,旨在帮助大家更加容量的理解Reactor反应堆的设计思想,为Netty线程模型打下扎实的基础。...

Netty与Reactor模式

一:Netty、NIO、多线程? 时隔很久终于又更新了!之前一直迟迟未动也是因为积累不够,后面比较难下手。过年期间@李林锋hw发布了一个Netty5.0架构剖析和源码解读 http://vdis...
  • gadbee5
  • gadbee5
  • 2015年02月10日 18:12
  • 302

Netty教程-Reactor模式

Reactor模式是什么?Reactor是用于处理多个客户端的请求的设计模式。应用程序提供的每一种服务都可能包括多个方法,并且有必要为这每一个服务分配独立的请求处理器(也可以说是 event hand...

Netty权威指南-Reactor模式

Java NIO非堵塞技术实际是采取反应器模式,或者说是观察者(observer)模式为我们监察I/O端口,如果有内容进来,会自动通知我们,这样,我们就不必开启多个线程死等,从外界看,实现了流畅的I/...

Netty5.0架构剖析和源码解读.PDF

  • 2017年10月26日 10:39
  • 3.34MB
  • 下载

Netty源码解读之线程

  • 2015年09月22日 16:41
  • 656KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Netty源码解读(四)Netty与Reactor模式
举报原因:
原因补充:

(最多只允许输入30个字)