标签：
一、引子nio是java的IO框架里边十分重要的一部分内容，其最核心的就是提供了非阻塞IO的处理方式，最典型的应用场景就是处理网络连接。很多同学提起nio都能说起一二，但是细究其背后的原理、思想往往就开始背书，说来说去都是那么几句，其中不少人并不见的真的很理解。本人之前就属于此类，看了很多书和博客，但是大多数都只是讲了三件套和怎么使用，很少会很细致的讲背后的思想，那本次我们就来扒一扒吧。 很多博客描述nio都是这么说的：基于Reactor模式实现的多路非阻塞高性能的网络IO。那么我们就从这个定义来分析，其中两个关键点：多路非阻塞和Reactor模式。(本来想把高性能也算进去，但是后来想想这个应该算前两者的结果)下边我们来分别搞懂这两块。
多路非阻塞其实准确的名字叫做IO多路复用模型，其是linux五种网络模型之一，也是当前网络编程最常使用的模型之一。至于详细的介绍请参考博客：高性能IO模型浅析(这个里边只给出了4中，没有信号驱动IO，但讲的很赞，特别是图)，这里仅作简要介绍和对比：
对比以上五种模型可以知道，IO复用模型从效率和实现成本综合而言目前是比较好的选择，这就是java基于该模型实现nio的根本原因。上边提到了IO复用模型的实现思想，其实这种思想在其他语言中早已实现(如C++中据说流弊哄哄超10w行代码的ACE,自适配通信环境，就采用了该模型)，并且提出了一个叫Reactor的设计模式。
Reactor模式，翻译过来叫做反引器模式，其目的是在事件驱动的应用中，将一个请求的能够分离并且调度给应用程序。我相信大多数人都没看明白前一句的意思（书还是要背的），说白了就是对于一个请求的多个事件（如连接、读写等），经过这种模式的处理，能够区分出来，并且分别交给对应的处理模块处理。废话不多说，来看下一个简图：
再来看个简图吧：
基本上和Reactor能对应上，少了个dispatcher，这是由于jdk本身提供的nio比较基本，dispatcher一般都由我们自己实现，而在我理解中，mina、netty这些框架很重要的一方面也是提供了该部分的实现。
从《netty权威指南》上抄了个例子以及配图，而且代码没有客户端的，大家可以瞄一眼吧（为什么没有？因为已经快一点了，我不想写了......）: 服务器端时序图：
客户端时序图：
服务器端代码：
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做对应处理
}
}
NIO 有一个主要的类Selector，这个类似一个观察者，只要我们把需要探知的socketchannel告诉Selector，我们接着做别的事情，当有事件发生时，他会通知我们，传回一组SelectionKey，我们读取这些Key，就会获得我们刚刚注册过的socketchannel，然后，我们从这个Channel中读取数据，接着我们可以处理这些数据。
反应器模式与观察者模式在某些方面极为相似：
当一个主体发生改变时，所有依属体【在主体中注册的对象】都得到通知。不过，观察者模式与单个事件源关联，而反应器模式则与多个事件源关联 。
一般模型
我们想象以下情形：长途客车在路途上，有人上车有人下车，但是乘客总是希望能够在客车上得到休息。
传统的做法是：每隔一段时间（或每一个站），司机或售票员对每一个乘客询问是否下车。
反应器模式做法是：汽车是乘客访问的主体（Reactor），乘客上车后，到售票员（acceptor）处登记，之后乘客便可以休息睡觉去了，当到达乘客所要到达的目的地后，售票员将其唤醒即可。
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
标签：
原文地址：http://www.cnblogs.com/softidea/p/5042813.html
