您的位置：首页 > Web前端 > React

Netty与Reactor模式

2015-02-13 09:54 507 查看
转载自并发编程网 – ifeve.com (http://ifeve.com/netty-reactor-4/)


一：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等待时间。





2、Netty中的Reactor与NIO
好了，了解了多线程下的Reactor模式，我们来看看Netty吧（以下部分主要针对NIO，OIO部分更加简单一点，不重复介绍了）。Netty里对应mainReactor的角色叫做“Boss”，而对应subReactor的角色叫做”Worker”。Boss负责分配请求，Worker负责执行，好像也很贴切！以TCP的Server端为例，这两个对应的实现类分别为
NioServerBoss
和
NioWorker
（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
这个叫法，以及区分
NioBoss
和
NioWorker
的做法稍微繁琐了点，干脆就将这些合并成了
NioEventLoop
，从此这两个角色就不做区分了。我倒是觉得新版本的会更优雅一点。

3、Netty中的多线程
下面我们来看Netty的多线程部分。一旦对应的Boss或者Worker启动，就会分配给它们一个线程去一直执行。对应的概念为
BossPool
和
WorkerPool
。对于每个
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

参考资料：

Scalable IO in Java http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf
Netty5.0架构剖析和源码解读 http://vdisk.weibo.com/s/C9LV9iVqH13rW/1391437855
Reactor pattern http://en.wikipedia.org/wiki/Reactor_pattern
Reactor – An Object Behavioral Pattern for Demultiplexing and Dispatching Handles for Synchronous Events http://www.cs.wustl.edu/~schmidt/PDF/reactor-siemens.pdf
高性能网络编程6–reactor反应堆与定时器管理 http://blog.csdn.net/russell_tao/article/details/17452997
IO – 同步，异步，阻塞，非阻塞 （亡羊补牢篇）http://blog.csdn.net/historyasamirror/article/details/5778378

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

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

本文链接地址: Netty源码解读（四）Netty与Reactor模式
                                            

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                network programming
                                                nio
                                                reactor
                                                多线程
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航