- 浏览: 173126 次
- 性别:
- 来自: 南京
文章分类
- 全部博客 (77)
- Java (12)
- J2EE (1)
- DHTML (8)
- oracle (10)
- javascript (2)
- spring (4)
- hibernate (3)
- struts (1)
- mysql (6)
- JDBC (2)
- others (1)
- css (1)
- eclipse/myeclipse (1)
- lucene (2)
- Servlet (3)
- appache (1)
- jasperreport ireport (0)
- DWR (2)
- flex (0)
- SQL Server (1)
- svn (1)
- jsp (1)
- Xml (1)
- Ibatise (0)
- jeffy (1)
- linux (1)
- mina (0)
- Java 网络编程 (7)
最新评论
-
zifangsky:
关于“继承HttpServletRequestWrapper以 ...
HttpServletRequestWrapper 用法 -
DavyJones2010:
有趣.在filter里用RequestWrapper替换掉Re ...
HttpServletRequestWrapper 用法 -
孙子宸:
好人,有空顶你
HttpServletRequestWrapper 用法 -
lz726:
三克油~
HttpServletRequestWrapper 用法 -
focus2008:
it's cool
HttpServletRequestWrapper 用法
Java NIO非堵塞应用通常适用用在I/O读写等方面,我们知道,系统运行的性能瓶颈通常在I/O读写,包括对端口和文件的操作上,过去,在打开一个I/O通道后,read()将一直等待在端口一边读取字节内容,如果没有内容进来,read()也是傻傻的等,这会影响我们程序继续做其他事情,那么改进做法就是开设线程,让线程去等待,但是这样做也是相当耗费资源的。
Java NIO非堵塞技术实际是采取Reactor模式,或者说是Observer模式为我们监察I/O端口,如果有内容进来,会自动通知我们,这样,我们就不必开启多个线程死等,从外界看,实现了流畅的I/O读写,不堵塞了。
Java NIO出现不只是一个技术性能的提高,你会发现网络上到处在介绍它,因为它具有里程碑意义,从JDK1.4开始,Java开始提高性能相关的功能,从而使得Java在底层或者并行分布式计算等操作上已经可以和C或Perl等语言并驾齐驱。
如果你至今还是在怀疑Java的性能,说明你的思想和观念已经完全落伍了,Java一两年就应该用新的名词来定义。从JDK1.5开始又要提供关于线程、并发等新性能的支持,Java应用在游戏等适时领域方面的机会已经成熟,Java在稳定自己中间件地位后,开始蚕食传统C的领域。
本文主要简单介绍NIO的基本原理,在下一篇文章中,将结合Reactor模式和著名线程大师Doug Lea的一篇文章深入讨论。
NIO主要原理和适用。
NIO 有一个主要的类Selector,这个类似一个观察者,只要我们把需要探知的socketchannel告诉Selector,我们接着做别的事情,当有事件发生时,他会通知我们,传回一组SelectionKey,我们读取这些Key,就会获得我们刚刚注册过的socketchannel,然后,我们从这个Channel中读取数据,放心,包准能够读到,接着我们可以处理这些数据。
Selector内部原理实际是在做一个对所注册的channel的轮询访问,不断的轮询(目前就这一个算法),一旦轮询到一个channel有所注册的事情发生,比如数据来了,他就会站起来报告,交出一把钥匙,让我们通过这把钥匙来读取这个channel的内容。
了解了这个基本原理,我们结合代码看看使用,在使用上,也在分两个方向,一个是线程处理,一个是用非线程,后者比较简单,看下面代码:
package com.yukh.nio.selector; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.Socket; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Iterator; import java.util.Set; /** * 这是一个守候在端口9000的noblock server例子, * 如果我们编制一个客户端程序,就可以对它进行互动操作, * 或者使用telnet 主机名 90000 可以链接上。 * @author Administrator * @version */ public class NBTest { /** Creates new NBTest */ public NBTest() { } public void startServer() throws Exception { int channels = 0; int nKeys = 0; int currentSelector = 0; // 使用Selector Selector selector = Selector.open(); // 建立Channel 并绑定到9000端口 ServerSocketChannel ssc = ServerSocketChannel.open(); InetSocketAddress address = new InetSocketAddress(InetAddress .getLocalHost(), 9000); ssc.socket().bind(address); // 使设定non-blocking的方式。 ssc.configureBlocking(false); // 向Selector注册Channel及我们有兴趣的事件 SelectionKey s = ssc.register(selector, SelectionKey.OP_ACCEPT); printKeyInfo(s); while (true) // 不断的轮询 { debug("NBTest: Starting select"); // Selector通过select方法通知我们我们感兴趣的事件发生了。 nKeys = selector.select(); // 如果有我们注册的事情发生了,它的传回值就会大于0 if (nKeys > 0) { debug("NBTest: Number of keys after select operation: " + nKeys); // Selector传回一组SelectionKeys // 我们从这些key中的channel()方法中取得我们刚刚注册的channel。 Set selectedKeys = selector.selectedKeys(); Iterator i = selectedKeys.iterator(); while (i.hasNext()) { s = (SelectionKey) i.next(); printKeyInfo(s); debug("NBTest: Nr Keys in selector: " + selector.keys().size()); // 一个key被处理完成后,就都被从就绪关键字(ready keys)列表中除去 i.remove(); if (s.isAcceptable()) { // 从channel()中取得我们刚刚注册的channel。 Socket socket = ((ServerSocketChannel) s.channel()) .accept().socket(); SocketChannel sc = socket.getChannel(); sc.configureBlocking(false); sc.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE); System.out.println(++channels); } else { debug("NBTest: Channel not acceptable"); } } } else { debug("NBTest: Select finished without any keys."); } } } private static void debug(String s) { System.out.println(s); } private static void printKeyInfo(SelectionKey sk) { String s = new String(); s = "Att: " + (sk.attachment() == null ? "no" : "yes"); s += ", Read: " + sk.isReadable(); s += ", Acpt: " + sk.isAcceptable(); s += ", Cnct: " + sk.isConnectable(); s += ", Wrt: " + sk.isWritable(); s += ", Valid: " + sk.isValid(); s += ", Ops: " + sk.interestOps(); s += ",--------------------------"; debug(s); } /** * @param args * the command line arguments */ public static void main(String args[]) { NBTest nbTest = new NBTest(); try { nbTest.startServer(); } catch (Exception e) { e.printStackTrace(); } } }
这是一个守候在端口9000的noblock server例子,如果我们编制一个客户端程序,就可以对它进行互动操作,或者使用telnet 主机名 90000 可以链接上。
当前分布式计算 Web Services盛行天下,这些网络服务的底层都离不开对socket的操作。他们都有一个共同的结构:
1. Read request
2. Decode request
3. Process service
4. Encode reply
5. Send reply
Reactor模式参与者
1.Reactor 负责响应IO事件,一旦发生,广播发送给相应的Handler去处理,这类似于AWT的thread
2.Handler 是负责非堵塞行为,类似于AWT ActionListeners;同时负责将handlers与event事件绑定,类似于AWT addActionListener
Java的NIO为reactor模式提供了实现的基础机制,它的Selector当发现某个channel有数据时,会通过SlectorKey来告知我们,在此我们实现事件和handler的绑定。
我们来看看Reactor模式代码:
package com.yukh.nio.selector; 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.nio.channels.SocketChannel; import java.util.Iterator; import java.util.Set; import org.apache.log4j.Logger; /** * 以下代码中巧妙使用了SocketChannel的attach功能, *将Hanlder和可能会发生事件的channel链接在一起,当发生事件时, *可以立即触发相应链接的Handler。 */ public class Reactor implements Runnable { public static Logger logger = Logger.getLogger(Reactor.class); final Selector selector; final ServerSocketChannel serverSocket; Reactor(int port) throws IOException { selector = Selector.open(); // 创建选择器 serverSocket = ServerSocketChannel.open(); // 打开服务器套接字通道 InetSocketAddress address = new InetSocketAddress(InetAddress .getLocalHost(), port); serverSocket.socket().bind(address); serverSocket.configureBlocking(false); // 调整此通道的阻塞模式。 - 异步 SelectionKey sk = serverSocket.register(selector, // 向selector注册该channel SelectionKey.OP_ACCEPT); // 用于套接字接受操作的操作集位。 logger.debug("-->Start serverSocket.register!"); // 利用sk的attache功能绑定Acceptor 如果有事情,触发Acceptor sk.attach(new Acceptor()); // 将给定的对象附加到此键。 logger.debug("-->attach(new Acceptor()!"); } public void run() { // normally in a new Thread try { while (!Thread.interrupted()) { selector.select(); Set selected = selector.selectedKeys(); Iterator it = selected.iterator(); // Selector如果发现channel有OP_ACCEPT或READ事件发生,下列遍历就会进行。 while (it.hasNext()) // 来一个事件 第一次触发一个accepter线程 // 以后触发SocketReadHandler dispatch((SelectionKey) (it.next())); selected.clear(); } } catch (IOException ex) { logger.debug("reactor stop!" + ex); } } void dispatch(SelectionKey k) { Runnable r = (Runnable) (k.attachment()); if (r != null) { r.run(); } } class Acceptor implements Runnable { // inner public void run() { try { logger.debug("-->ready for accept!"); SocketChannel c = serverSocket.accept(); if (c != null) new SocketReadHandler(selector, c); // 调用Handler来处理channel } catch (IOException ex) { logger.debug("accept stop!" + ex); } } } }
以上代码中巧妙使用了SocketChannel的attach功能,将Hanlder和可能会发生事件的channel链接在一起,当发生事件时,可以立即触发相应链接的Handler。
再看看Handler代码:
package com.yukh.nio.selector; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.SocketChannel; import org.apache.log4j.Logger; public class SocketReadHandler implements Runnable { public static Logger logger = Logger.getLogger(SocketReadHandler.class); // private Test test=new Test(); final SocketChannel socket; final SelectionKey sk; static final int READING = 0, SENDING = 1; int state = READING; public SocketReadHandler(Selector sel, SocketChannel c) throws IOException { socket = c; socket.configureBlocking(false); sk = socket.register(sel, 0); // 将SelectionKey绑定为本Handler 下一步有事件触发时,将调用本类的run方法。 // 参看dispatch(SelectionKey k) sk.attach(this); // 同时将SelectionKey标记为可读,以便读取。 sk.interestOps(SelectionKey.OP_READ); sel.wakeup(); } public void run() { try { // test.read(socket,input); readRequest(); } catch (Exception ex) { logger.debug("readRequest error" + ex); } } /** * 处理读取data * * @param key * @throws Exception */ private void readRequest() throws Exception { ByteBuffer input = ByteBuffer.allocate(1024); input.clear(); try { int bytesRead = socket.read(input); // 激活线程池 处理这些request // requestHandle(new Request(socket,btt)); } catch (Exception e) { } } }
注意在Handler里面又执行了一次attach,这样,覆盖前面的Acceptor,下次该Handler又有READ事件发生时,将直接触发Handler.从而开始了数据的读 处理 写 发出等流程处理。
发表评论
-
linux 学习记录
2012-02-29 17:23 01. 中文乱码和中文输入法 安装中文包 ... -
java concurrent
2011-08-12 18:05 1210我们都知道,在JDK1.5之前,Java中要进行业务并发时 ... -
java HashMap
2011-07-27 21:02 980在Java的世界里,无论类还是各种数据,其结构的处理是整个程序 ... -
byte 新说
2011-01-29 15:51 1200Java虚拟机中没有byte类 ... -
Java对象及其引用
2010-03-26 16:04 1066初学Java时,在很长一段 ... -
java中的值传递和引用传递
2010-03-25 17:53 1625值传递:方法调用时,实际参数把它的值传递给对应的形式参数,方法 ... -
JAVA 精确计算
2009-09-14 08:52 1579在 Java 程序中使用浮点数和小数充满着陷阱。浮点数和小数不 ... -
Java关键字final、static使用总结
2009-08-05 21:08 813一、final 根据程序上下文环境,Java ... -
tomcat 定时重启脚本
2008-11-28 11:00 1425http://lvchun.1cdy.com/read.php ... -
tomcat 定时重启
2008-11-28 10:54 1247http://rails2007.iteye.com/blog ... -
个人认为比较好的文章收藏
2008-09-08 19:12 10771、Unsupported major.minor versi ... -
Map 取值
2008-09-08 18:58 3298一、 Java 容器 1. Map取值 方法一. ...
相关推荐
### Java响应式编程:Reactor 3 和 Spring WebFlux #### 一、响应式编程简介 响应式编程(Reactive Programming)是一种编程范式,它允许开发者通过声明式的方式处理异步数据流和事件。这种编程模式的核心在于能够...
主要用于解决高并发场景下的系统设计问题,而Java的NIO(Non-blocking Input/Output,非阻塞I/O)是Java平台提供的一种I/O模型,它支持基于事件的多路复用,为实现Reactor模式提供了基础。 Reactor模式的核心思想是...
Java Reactor反应器模式使用方法详解 Java Reactor反应器模式使用方法详解是一种高性能网络编程模式,广泛应用于服务器软件和中间件中,如Nginx、Redis、Netty等。反应器模式由Reactor反应器线程和Handlers处理器两...
在Java中,NIO(Non-blocking I/O)框架就是Reactor模式的一个典型应用,它允许一个线程处理多个通道(Channel)上的I/O事件,而不是为每个连接创建一个单独的线程。NIO中的Selector组件就是Reactor的核心,它能够...
在React框架中,Reactor是其核心库之一,专门用于构建响应式应用程序。本篇文章将详细解读Reactor 3的中文帮助文档,帮助用户理解非阻塞响应式框架的使用方法及其原理,尤其是Spring WebFlux底层实现的相关知识。 ...
在Java中,NIO(非阻塞I/O)库为实现Reactor模式提供了基础。Netty基于NIO,并在其之上构建了一套高效且易用的网络编程框架。 Netty中的Reactor分为两个主要部分:主线程(BossGroup)和工作线程(WorkerGroup)。...
在反应器模式的Java实现中,一个Reactor(反应器)负责监听和分发事件,它持续监测一个或多个输入源,一旦有事件发生,它就将事件分发给相应的处理器进行处理。处理器(Handler)定义了事件处理的方法,每个处理器...
Netty的EventLoop是Reactor的核心,每个EventLoop都有一个与之关联的I/O线程,负责执行注册在其上的Channel的任务。EventLoop内部维护了一个待处理事件队列,当事件发生时,如新连接、数据到达或通道关闭等,这些...
**RxJava**是Java中最流行的反应式编程库之一。它提供了观察者模式的实现,可以轻松处理异步和基于事件的数据流。RxJava的主要特点包括: - **链式操作**:通过链式调用操作符,可以非常灵活地组合和转换数据流。 -...
Socket NIO 单 Reactor 模式是一种在 Java 中实现高性能网络编程的技术,它结合了非阻塞I/O(New I/O,即NIO)和Reactor设计模式。本示例代码旨在帮助开发者理解如何使用Java NIO和Reactor模式构建网络服务。尽管...
总之,《Reactor 指南中文版》为开发者提供了深入理解Reactor及其在Java生态系统中的应用的宝贵资源,有助于提升应用程序的性能和可扩展性。通过学习和实践,开发者可以更好地利用Reactor来构建高效、灵活的异步应用...
本文将深入解析这份文档及其翻译,带你理解Reactor模式的设计原理及其在Java中的应用。 首先,让我们了解什么是Scalable IO。在计算机科学中,可扩展性(Scalability)是指系统能够处理增加的工作负载,而不会降低...
《深入理解Reactor Netty:Java中的高性能网络库》 Reactor Netty是Spring Reactor项目的一部分,它是一个用于构建高性能、反应式网络应用的Java库。Reactor Netty的核心理念在于利用非阻塞I/O和事件驱动模型,提供...
Java Netty 是一个高性能的网络编程框架,Reactor 模式是其核心组件之一。Reactor 模式是指在网络编程中,使用单个线程或多个线程来处理所有的IO操作。下面我们将详细介绍 Java Netty Reactor 的三种线程模型。 1. ...
这本书深入探讨了在Java环境中如何构建可扩展的输入/输出系统,特别关注了Reactor模式,这是一种用于处理大量并发I/O事件的设计模式。在现代网络应用程序中,有效地管理I/O操作是性能优化的关键,Doug Lea的这部作品...
在Java开发领域,Reactor和Flux是两个非常重要的概念,尤其在响应式编程的世界里。Reactor是一个基于Java的反应式流库,它遵循Reactive Streams规范,并且是Spring框架的一部分。Flux是Reactor提供的一种编程模型,...
Proactor-Reactor 模式是高性能服务器设计的核心思想之一,它们都是基于 I/O 多路复用的技术实现的。下面我们来详细了解 Proactor-Reactor 模式的设计思想和实现机理。 问题背景 在设计高性能服务器时,如何处理...
Scalable IO in Java是java.util.concurrent包的作者,大师Doug Lea关于分析与构建可伸缩的高性能IO服务的一篇经典文章...同时压缩包内还包含reactor-siemens.pdf描述reactor的英文论文,有助于加深reactor模式的理解。
Reactor-Core是Java生态系统中的一个关键组件,它是一个强大的开源项目,专为实现JVM上的无阻塞反应式流而设计。本文将深入探讨Reacto-Core的核心概念、功能特性以及如何利用其构建高效的应用程序。 Reactor-Core是...
异步模式的场景包括但不限于网络IO操作,例如使用Java NIO框架Netty,以及基于Reactor模式的响应式编程。在这些场景下,异步API可以有效避免线程阻塞,提高系统的吞吐量。例如,对于磁盘IO,Java NIO2提供了异步API...