java NIO中的Reactor相关知识汇总 (转)

java NIO中的Reactor相关知识汇总 (转)一、引子

nio是java的IO框架里边十分重要的一部分内容,其最核心的就是提供了非阻塞IO的处理方式,最典型的应用场景就是处理网络连接。很多同学提起nio都能说起一二,但是细究其背后的原理、思想往往就开始背书,说来说去都是那么几句,其中不少人并不见的真的很理解。本人之前就属于此类,看了很多书和博客,但是大多数都只是讲了三件套和怎么使用,很少会很细致的讲背后的思想,那本次我们就来扒一扒吧。     很多博客描述nio都是这么说的:基于Reactor模式实现的多路非阻塞高性能的网络IO。那么我们就从这个定义来分析,其中两个关键点:多路非阻塞和Reactor模式。(本来想把高性能也算进去,但是后来想想这个应该算前两者的结果)下边我们来分别搞懂这两块。

二、网络IO模型

多路非阻塞其实准确的名字叫做IO多路复用模型,其是linux五种网络模型之一,也是当前网络编程最常使用的模型之一。至于详细的介绍请参考博客:高性能IO模型浅析(这个里边只给出了4中,没有信号驱动IO,但讲的很赞,特别是图),这里仅作简要介绍和对比:

  • 阻塞IO:java中老的bio便是这种模式,在接到事件(数据到达、数据拷贝完成等)前程序需阻塞等待。优点是编码简单,缺点是效率低,处理程序阻塞会导致cpu利用率很低。
  • 非阻塞IO:在未接到事件时处理程序一直主动轮询,这样处理程序无需阻塞,可以在轮询间歇去干别的,但是轮询会造成重复请求,同样浪费资源。以前java中实现的的伪异步模式就是采用这种思想。
  • IO复用模型:增加了对socket的事件监听器(selector),从而把处理程序和对应的socket事件解耦,所用的socket连接都注册在监听器,在等待阶段只有监听器会阻塞,处理线程从监听器获取事件对socket连接处理即可,而且一个处理线程可以对应多个连接(前两种一般都是一个socket连接起一个线程,这就是为什么叫复用),有点是节省资源,由于处理程序能够被多个连接复用,因此少数的线程就能处理大量连接。缺点同样因为复用,如果是大量费时处理的连接(如大量连接上传大文件),很容易造成线程占满而导致新连接失败。
  • 信号驱动IO模型:在数据准别阶段无需阻塞,只需向系统注册一个信号,在数据准备好后,系统会响应该信号。该模型依赖于系统实现,而且信号通信使用比较麻烦,因此java中未有对应实现。
  • 异步IO:与信号驱动IO很类似,而且在数据拷贝阶段(指数据从系统缓冲区拷贝至程序自己的缓冲区,其他模型改阶段程序都需要阻塞等待)同样可以异步处理。有点不必多说,效率很高,缺点是依赖系统底层实现。目前很多语言都提供该模型的实现,jdk1.7之后同样在concurrent包中提供了。

对比以上五种模型可以知道,IO复用模型从效率和实现成本综合而言目前是比较好的选择,这就是java基于该模型实现nio的根本原因。上边提到了IO复用模型的实现思想,其实这种思想在其他语言中早已实现(如C++中据说流弊哄哄超10w行代码的ACE,自适配通信环境,就采用了该模型),并且提出了一个叫Reactor的设计模式。

三、Reactor模式

Reactor模式,翻译过来叫做反引器模式,其目的是在事件驱动的应用中,将一个请求的能够分离并且调度给应用程序。我相信大多数人都没看明白前一句的意思(书还是要背的),说白了就是对于一个请求的多个事件(如连接、读写等),经过这种模式的处理,能够区分出来,并且分别交给对应的处理模块处理。废话不多说,来看下一个简图:

java NIO中的Reactor相关知识汇总 (转)

    可以看到Reactor模式中组件有acceptor、dispatcher和handler(这里只是拿一种实现做个例子,真实的实现各有不同),其中acceptor中注册了各类事件,当连接有新的事件过来时,其会将事件交给dispatcher进行分发;dispatcher绑定了事件和对应处理程序handler的映射关系,当接到新事件时其会把事件分发到对应handler;而handler负责处理对应事件,这块就是我们的业务层了。
    从该模式我们可以发现,对于acceptor、dispatcher我们往往只需要一个线程作为入口即可,因为其并不会有耗时处理,效率很高,而handler则根据需要起几个线程即可(多数时候使用一个线程池实现),这正是IO复用模型期望的效果。
    下边我们会介绍NIO是如何实现该模式的,在此之前先介绍一下框架,其实除了NIO之外,基于JVM实现的还有其他Reactor框架,正好最近OSC牵头翻译了对应文档,有兴趣的可以看下:Reactor 指南

四、NIO

    NIO的细节就不多讲了,这里只介绍下三件套:
  • channel:管道,可以看做对流的封装,有点像pipe,不过其是全双工的。其好处是屏蔽了底层细节,不用关心流对应的是文件还是网络,也不用关心连接怎么处理的,而且全双工,不用考虑输入流或输出流,你只用使用buffer对其进行读写就行了。
  • buffer:channel的好基友,底层就是个字节数组,不同的是对其进行了封装,不仅提供了对基本类型的支持,而且内部维持了读写位置(postion、limit、capacity、mark等),还提供了便捷的方法(clear、flip)。对channel的读写必须通过buffer。
  • selector:这个不多说了,如果前边认真看基本上就明白干啥的,就是Reactor模式中Acceptor的实现。

再来看个简图吧:

java NIO中的Reactor相关知识汇总 (转)

基本上和Reactor能对应上,少了个dispatcher,这是由于jdk本身提供的nio比较基本,dispatcher一般都由我们自己实现,而在我理解中,mina、netty这些框架很重要的一方面也是提供了该部分的实现。

五、一个例子

从《netty权威指南》上抄了个例子以及配图,而且代码没有客户端的,大家可以瞄一眼吧(为什么没有?因为已经快一点了,我不想写了......): 服务器端时序图:

java NIO中的Reactor相关知识汇总 (转)

客户端时序图:

java NIO中的Reactor相关知识汇总 (转)

服务器端代码:

java NIO中的Reactor相关知识汇总 (转)
package com.gj.netty.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;
import java.util.Set; /**
* Created by guojing on 2015/6/7.
*/
public class MultiplexerTimerServer implements Runnable { private Selector selector;
private ServerSocketChannel servChannel;
private volatile boolean stop; public MultiplexerTimerServer(int port) {
try {
selector = Selector.open(); //新建多路复用selector
servChannel = ServerSocketChannel.open(); //新建channel
servChannel.configureBlocking(false); //设置非阻塞
servChannel.socket().bind(new InetSocketAddress(port),1024); //端口、块大小
servChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("TimeServer is start, port:" + port);
} catch (IOException e) {
e.printStackTrace();
} } public void run() {
while (!stop){
try {
selector.select(1000);
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> ketIt = keys.iterator();
SelectionKey key = null;
while (ketIt.hasNext()){
key = ketIt.next();
ketIt.remove();
//处理对应key事件
handler(key);
}
} catch (IOException e) {
e.printStackTrace();
} }
} private void handler(SelectionKey key){
//根据key去除channel做对应处理
}
}
java NIO中的Reactor相关知识汇总 (转)

http://www.cnblogs.com/good-temper/p/5003892.html

NIO 有一个主要的类Selector,这个类似一个观察者,只要我们把需要探知的socketchannel告诉Selector,我们接着做别的事情,当有事件发生时,他会通知我们,传回一组SelectionKey,我们读取这些Key,就会获得我们刚刚注册过的socketchannel,然后,我们从这个Channel中读取数据,接着我们可以处理这些数据。

反应器模式与观察者模式在某些方面极为相似:
当一个主体发生改变时,所有依属体【在主体中注册的对象】都得到通知。不过,观察者模式与单个事件源关联,而反应器模式则与多个事件源关联 。

一般模型

我们想象以下情形:长途客车在路途上,有人上车有人下车,但是乘客总是希望能够在客车上得到休息。

传统的做法是:每隔一段时间(或每一个站),司机或售票员对每一个乘客询问是否下车。

反应器模式做法是:汽车是乘客访问的主体(Reactor),乘客上车后,到售票员(acceptor)处登记,之后乘客便可以休息睡觉去了,当到达乘客所要到达的目的地后,售票员将其唤醒即可。
java NIO中的Reactor相关知识汇总 (转)
Demo:

package com.reactor;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;
import java.util.Set; /**
* 反应器模式
* 用于解决多用户访问并发问题
*
* 举个例子:餐厅服务问题
*
* 传统线程池做法:来一个客人(请求)去一个服务员(线程)
* 反应器模式做法:当客人点菜的时候,服务员就可以去招呼其他客人了,等客人点好了菜,直接招呼一声“服务员”
*
* @author linxcool
*/
public class Reactor implements Runnable{
public final Selector selector;
public final ServerSocketChannel serverSocketChannel; public Reactor(int port) throws IOException{
selector=Selector.open();
serverSocketChannel=ServerSocketChannel.open();
InetSocketAddress inetSocketAddress=new InetSocketAddress(InetAddress.getLocalHost(),port);
serverSocketChannel.socket().bind(inetSocketAddress);
serverSocketChannel.configureBlocking(false); //向selector注册该channel
SelectionKey selectionKey=serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); //利用selectionKey的attache功能绑定Acceptor 如果有事情,触发Acceptor
selectionKey.attach(new Acceptor(this));
} @Override
public void run() {
try {
while(!Thread.interrupted()){
selector.select();
Set<SelectionKey> selectionKeys= selector.selectedKeys();
Iterator<SelectionKey> it=selectionKeys.iterator();
//Selector如果发现channel有OP_ACCEPT或READ事件发生,下列遍历就会进行。
while(it.hasNext()){
//来一个事件 第一次触发一个accepter线程
//以后触发SocketReadHandler
SelectionKey selectionKey=it.next();
dispatch(selectionKey);
selectionKeys.clear();
}
}
} catch (IOException e) {
e.printStackTrace();
}
} /**
* 运行Acceptor或SocketReadHandler
* @param key
*/
void dispatch(SelectionKey key) {
Runnable r = (Runnable)(key.attachment());
if (r != null){
r.run();
}
} }
package com.reactor;

import java.io.IOException;
import java.nio.channels.SocketChannel; public class Acceptor implements Runnable{
private Reactor reactor;
public Acceptor(Reactor reactor){
this.reactor=reactor;
}
@Override
public void run() {
try {
SocketChannel socketChannel=reactor.serverSocketChannel.accept();
if(socketChannel!=null)//调用Handler来处理channel
new SocketReadHandler(reactor.selector, socketChannel);
} catch (IOException e) {
e.printStackTrace();
}
}
}
package com.reactor;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel; public class SocketReadHandler implements Runnable{
private SocketChannel socketChannel;
public SocketReadHandler(Selector selector,SocketChannel socketChannel) throws IOException{
this.socketChannel=socketChannel;
socketChannel.configureBlocking(false); SelectionKey selectionKey=socketChannel.register(selector, 0); //将SelectionKey绑定为本Handler 下一步有事件触发时,将调用本类的run方法。
//参看dispatch(SelectionKey key)
selectionKey.attach(this); //同时将SelectionKey标记为可读,以便读取。
selectionKey.interestOps(SelectionKey.OP_READ);
selector.wakeup();
} /**
* 处理读取数据
*/
@Override
public void run() {
ByteBuffer inputBuffer=ByteBuffer.allocate(1024);
inputBuffer.clear();
try {
socketChannel.read(inputBuffer);
//激活线程池 处理这些request
//requestHandle(new Request(socket,btt));
} catch (IOException e) {
e.printStackTrace();
}
}
}

http://blog.csdn.net/linxcool/article/details/7771952

上一篇:redisLock redis分布式锁


下一篇:树莓派4B 汇编实现串口打印