文档章节

Java NIO使用及原理分析 (四)

mrliuze
 mrliuze
发布于 2015/05/21 18:15
字数 1458
阅读 13
收藏 0

转载自:李会军•宁静致远

在上一篇文章中介绍了关于缓冲区的一些细节内容,现在终于可以进入NIO中最有意思的部分非阻塞I/O。通常在进行同步I/O操作时,如果读取数据,代码会阻塞直至有 可供读取的数据。同样,写入调用将会阻塞直至数据能够写入。传统的Server/Client模式会基于TPR(Thread per Request),服务器会为每个客户端请求建立一个线程,由该线程单独负责处理一个客户请求。这种模式带来的一个问题就是线程数量的剧增,大量的线程会增大服务器的开销。大多数的实现为了避免这个问题,都采用了线程池模型,并设置线程池线程的最大数量,这由带来了新的问题,如果线程池中有200个线程,而有200个用户都在进行大文件下载,会导致第201个用户的请求无法及时处理,即便第201个用户只想请求一个几KB大小的页面。传统的 Server/Client模式如下图所示:

NIO中非阻塞I/O采用了基于Reactor模式的工作方式,I/O调用不会被阻塞,相反是注册感兴趣的特定I/O事件,如可读数据到达,新的套接字连接等等,在发生特定事件时,系统再通知我们。NIO中实现非阻塞I/O的核心对象就是Selector,Selector就是注册各种I/O事件地 方,而且当那些事件发生时,就是这个对象告诉我们所发生的事件,如下图所示:

从图中可以看出,当有读或写等任何注册的事件发生时,可以从Selector中获得相应的SelectionKey,同时从 SelectionKey中可以找到发生的事件和该事件所发生的具体的SelectableChannel,以获得客户端发送过来的数据。关于 SelectableChannel的可以参考Java NIO使用及原理分析(一)

使用NIO中非阻塞I/O编写服务器处理程序,大体上可以分为下面三个步骤:

1. 向Selector对象注册感兴趣的事件
2. 从Selector中获取感兴趣的事件
3. 根据不同的事件进行相应的处理

接下来我们用一个简单的示例来说明整个过程。首先是向Selector对象注册感兴趣的事件:

  1. /* 
  2.  * 注册事件 
  3.  * */  
  4. protected Selector getSelector() throws IOException {  
  5.     // 创建Selector对象  
  6.     Selector sel = Selector.open();  
  7.       
  8.     // 创建可选择通道,并配置为非阻塞模式  
  9.     ServerSocketChannel server = ServerSocketChannel.open();  
  10.     server.configureBlocking(false);  
  11.       
  12.     // 绑定通道到指定端口  
  13.     ServerSocket socket = server.socket();  
  14.     InetSocketAddress address = new InetSocketAddress(port);  
  15.     socket.bind(address);  
  16.       
  17.     // 向Selector中注册感兴趣的事件  
  18.     server.register(sel, SelectionKey.OP_ACCEPT);   
  19.     return sel;  
  20. }  
/*
 * 注册事件
 * */
protected Selector getSelector() throws IOException {
    // 创建Selector对象
    Selector sel = Selector.open();
    
    // 创建可选择通道,并配置为非阻塞模式
    ServerSocketChannel server = ServerSocketChannel.open();
    server.configureBlocking(false);
    
    // 绑定通道到指定端口
    ServerSocket socket = server.socket();
    InetSocketAddress address = new InetSocketAddress(port);
    socket.bind(address);
    
    // 向Selector中注册感兴趣的事件
    server.register(sel, SelectionKey.OP_ACCEPT); 
    return sel;
}

创建了ServerSocketChannel对象,并调用configureBlocking()方法,配置为非阻塞模式,接下来的三行代码把该通道绑定到指定端口,最后向Selector中注册事件,此处指定的是参数是OP_ACCEPT,即指定我们想要监听accept事件,也就是新的连接发 生时所产生的事件,对于ServerSocketChannel通道来说,我们唯一可以指定的参数就是OP_ACCEPT。

从Selector中获取感兴趣的事件,即开始监听,进入内部循环:

  1. /* 
  2.  * 开始监听 
  3.  * */   
  4. public void listen() {   
  5.     System.out.println("listen on " + port);  
  6.     try {   
  7.         while(true) {   
  8.             // 该调用会阻塞,直到至少有一个事件发生  
  9.             selector.select();   
  10.             Set<SelectionKey> keys = selector.selectedKeys();  
  11.             Iterator<SelectionKey> iter = keys.iterator();  
  12.             while (iter.hasNext()) {   
  13.                 SelectionKey key = (SelectionKey) iter.next();   
  14.                 iter.remove();   
  15.                 process(key);   
  16.             }   
  17.         }   
  18.     } catch (IOException e) {   
  19.         e.printStackTrace();  
  20.     }   
  21. }  
/*
 * 开始监听
 * */ 
public void listen() { 
    System.out.println("listen on " + port);
    try { 
        while(true) { 
            // 该调用会阻塞,直到至少有一个事件发生
            selector.select(); 
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> iter = keys.iterator();
            while (iter.hasNext()) { 
                SelectionKey key = (SelectionKey) iter.next(); 
                iter.remove(); 
                process(key); 
            } 
        } 
    } catch (IOException e) { 
        e.printStackTrace();
    } 
}

在非阻塞I/O中,内部循环模式基本都是遵循这种方式。首先调用select()方法,该方法会阻塞,直到至少有一个事件发生,然后再使用selectedKeys()方法获取发生事件的SelectionKey,再使用迭代器进行循环。

最后一步就是根据不同的事件,编写相应的处理代码:
  1. /* 
  2.  * 根据不同的事件做处理 
  3.  * */  
  4. protected void process(SelectionKey key) throws IOException{  
  5.     // 接收请求  
  6.     if (key.isAcceptable()) {  
  7.         ServerSocketChannel server = (ServerSocketChannel) key.channel();  
  8.         SocketChannel channel = server.accept();  
  9.         channel.configureBlocking(false);  
  10.         channel.register(selector, SelectionKey.OP_READ);  
  11.     }  
  12.     // 读信息  
  13.     else if (key.isReadable()) {  
  14.         SocketChannel channel = (SocketChannel) key.channel();   
  15.         int count = channel.read(buffer);   
  16.         if (count > 0) {   
  17.             buffer.flip();   
  18.             CharBuffer charBuffer = decoder.decode(buffer);   
  19.             name = charBuffer.toString();   
  20.             SelectionKey sKey = channel.register(selector, SelectionKey.OP_WRITE);   
  21.             sKey.attach(name);   
  22.         } else {   
  23.             channel.close();   
  24.         }   
  25.         buffer.clear();   
  26.     }  
  27.     // 写事件  
  28.     else if (key.isWritable()) {  
  29.         SocketChannel channel = (SocketChannel) key.channel();   
  30.         String name = (String) key.attachment();   
  31.           
  32.         ByteBuffer block = encoder.encode(CharBuffer.wrap("Hello " + name));   
  33.         if(block != null)  
  34.         {  
  35.             channel.write(block);  
  36.         }  
  37.         else  
  38.         {  
  39.             channel.close();  
  40.         }  
  41.   
  42.      }  
  43. }  
/*
 * 根据不同的事件做处理
 * */
protected void process(SelectionKey key) throws IOException{
    // 接收请求
    if (key.isAcceptable()) {
        ServerSocketChannel server = (ServerSocketChannel) key.channel();
        SocketChannel channel = server.accept();
        channel.configureBlocking(false);
        channel.register(selector, SelectionKey.OP_READ);
    }
    // 读信息
    else if (key.isReadable()) {
        SocketChannel channel = (SocketChannel) key.channel(); 
        int count = channel.read(buffer); 
        if (count > 0) { 
            buffer.flip(); 
            CharBuffer charBuffer = decoder.decode(buffer); 
            name = charBuffer.toString(); 
            SelectionKey sKey = channel.register(selector, SelectionKey.OP_WRITE); 
            sKey.attach(name); 
        } else { 
            channel.close(); 
        } 
        buffer.clear(); 
    }
    // 写事件
    else if (key.isWritable()) {
        SocketChannel channel = (SocketChannel) key.channel(); 
        String name = (String) key.attachment(); 
        
        ByteBuffer block = encoder.encode(CharBuffer.wrap("Hello " + name)); 
        if(block != null)
        {
            channel.write(block);
        }
        else
        {
            channel.close();
        }

     }
}

此处分别判断是接受请求、读数据还是写事件,分别作不同的处理。

到这里关于Java NIO使用及原理分析的四篇文章就全部完成了。Java NIO提供了通道、缓冲区、选择器这样一组抽象概念,极大的简化了我们编写高性能并发型服务器程序,后面有机会我会继续谈谈使用Java NIO的一些想法。

(完)

本文转载自:http://blog.csdn.net/wuxianglong/article/details/6612282

共有 人打赏支持
mrliuze
粉丝 14
博文 155
码字总数 12377
作品 0
浦东
程序员
私信 提问
Java NIO原理 图文分析及代码实现

Java NIO原理图文分析及代码实现 前言: 最近在分析hadoop的RPC(Remote Procedure Call Protocol ,远程过程调用协议,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术...

囚兔
2015/04/29
0
0
Java NIO原理图文分析及代码实现

前言: 最近在分析hadoop的RPC(Remote Procedure Call Protocol ,远程过程调用协议,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议。可以参考:http://baik...

SunnyWu
2014/11/05
0
1
Java NIO原理图文分析及代码实现

Java IO 在Client/Server模型中,Server往往需要同时处理大量来自Client的访问请求,因此Server端需采用支持高并发访问的架构。一种简单而又直接的解决方案是“one-thread-per-connection”。...

只想一个人静一静
2014/02/22
0
1
Java NIO原理图文分析及代码实现

前言: 最近在分析hadoop的RPC(Remote Procedure Call Protocol ,远程过程调用协议,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议。可以参考:http://baik...

phacks
2015/08/19
0
0
跳槽时,这些Java面试题99%会被问到

我在 Oracle 已经工作了近 7 年,面试过从初级到非常资深的Java工程师,且由于 Java 组工作任务的特点,我非常注重面试者的计算机科学基础和编程语言的理解深度,可以不要求面试者非要精通 ...

Java小铺
08/15
0
0

没有更多内容

加载失败,请刷新页面

加载更多

集群介绍 ..

12月19日任务 18.1 集群介绍 18.2 keepalived介绍 18.3/18.4/18.5 用keepalived配置高可用集群 一.集群介绍 根据功能划分为两大类:高可用和负载均衡 高可用集群通常为两台服务器,一台工作,...

hhpuppy
12分钟前
0
0
TensorFlow的基础概念02

TensorFlow的计算流图 import osos.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'#TensorFlow的计算模型,数据流图'''TensorFlow = Tensor + FlowTensor 张量 数据结构:多维数组Flo...

怪咖先生forever
18分钟前
1
0
大数据技术的发展趋势

大数据领域已经涌现出了大量新的技术,它们成为大数据采集、存储、处理和呈现的有力武器。这些技术下一步将如何发展?它们之中哪些技术将广为流行?又会诞生哪些新的技术? 技术趋向多样化,...

董黎明
33分钟前
7
0
藏在正则表达式里的陷阱

前几天线上一个项目监控信息突然报告异常,上到机器上后查看相关资源的使用情况,发现 CPU 利用率将近 100%。通过 Java 自带的线程 Dump 工具,我们导出了出问题的堆栈信息。 我们可以看到所...

前端小攻略
35分钟前
3
0
关联更新,关联查询

关联更新 update A,B SET A.c1=B.c1,A.c2=B.c2 where A.id=B.id and ... update A inner join on A.id=B.id set A.c1=B.c1,A.c2=B.c2 where... 关联查询 交叉连接(cross join),内连接(inner ......

关元
39分钟前
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部