说实话转载的这篇文章没有看明白!
当前分布式计算 Web Services盛行天下,这些网络服务的底层都离不开对socket的操作。他们都有一个共同的结构:
1. Read request
2. Decode request
3. Process service
4. Encode reply
5. Send reply
经典的网络服务的设计如下图,在每个线程中完成对数据的处理:
但这种模式在用户负载增加时,性能将下降非常的快。我们需要重新寻找一个新的方案,保持数据处理的流畅,很显然,事件触发机制是最好的解决办法,当有事件发生时,会触动handler,然后开始数据的处理。
Reactor模式类似于AWT中的Event处理:
Reactor模式参与者
1.Reactor 负责响应IO事件,一旦发生,广播发送给相应的Handler去处理,这类似于AWT的thread
2.Handler 是负责非堵塞行为,类似于AWT ActionListeners;同时负责将handlers与event事件绑定,类似于AWT
addActionListener
如图:
Java的NIO为reactor模式提供了实现的基础机制,它的Selector当发现某个channel有数据时,会通过SlectorKey来告知我们,在此我们实现事件和handler的绑定。
我们来看看Reactor模式代码:
public class Reactor implements Runnable{
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);
//向selector注册该channel
SelectionKey sk =serverSocket.register(selector,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);
}
}
//运行Acceptor或SocketReadHandler
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)
//调用Handler来处理channel
new SocketReadHandler(selector, c);
}
catch(IOException ex) {
logger.debug("accept stop!"+ex);
}
}
}
}
|
以上代码中巧妙使用了SocketChannel的attach功能,将Hanlder和可能会发生事件的channel链接在一起,当发生事件时,可以立即触发相应链接的Handler。
再看看Handler代码:
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.从而开始了数据的读 处理 写 发出等流程处理。
将数据读出后,可以将这些数据处理线程做成一个线程池,这样,数据读出后,立即扔到线程池中,这样加速处理速度:
更进一步,我们可以使用多个Selector分别处理连接和读事件。
一个高性能的Java网络服务机制就要形成,激动人心的集群并行计算即将实现。
分享到:
相关推荐
标题"Scalable IO in Java.doc"指向的是关于如何在Java中实现可扩展的I/O操作,这通常是通过使用NIO库来实现的。NIO的核心理念是允许程序在等待数据就绪时执行其他任务,而不是简单地阻塞等待。这种模型在处理多个...
Scalable IO in Java是java.util.concurrent包的作者,大师Doug Lea关于分析与构建可伸缩的高性能IO服务的一篇经典文章,在文章中Doug Lea通过各个角度,循序渐进的梳理了服务开发中的相关问题,以及在解决问题的...
《Scalable IO in Java》是由Java领域的大师Doug Lea撰写的一份PPT文档,主要探讨了如何在Java环境中实现可扩展的I/O处理。本文将深入解析这份文档及其翻译,带你理解Reactor模式的设计原理及其在Java中的应用。 ...
《可扩展的Java IO》是Doug Lea撰写的一本关于如何在Java中实现高效、可扩展输入输出操作的重要著作。这本书对于理解Java平台上的并发和IO机制,特别是对于那些需要处理大量数据或构建高并发应用的开发者来说,是不...
《Scalable IO in Java》是由Java领域的大师Doug Lea撰写的一本关于高效I/O处理的著作。这本书深入探讨了在Java环境中如何构建可扩展的输入/输出系统,特别关注了Reactor模式,这是一种用于处理大量并发I/O事件的...
《Scalable IO in Java》是由Java领域知名专家Doug Lea撰写的一本关于Java高性能I/O编程的著作。这本书深入探讨了如何在Java环境中实现可扩展的输入/输出操作,特别是利用非阻塞I/O(Non-blocking I/O,简称NIO)...
从提供的文件列表来看,"Scalable IO in Java -Doug Lea.pdf"可能是该主题的详细论述,而"1.pptx"可能是相关的演示文稿或课程幻灯片,它们将更深入地阐述这些概念并提供实例分析。阅读这些材料,开发者可以学习如何...
本文将介绍Scalable IO in Java一书,其作者是Doug Lea,他同时也是Java并发编程领域的权威。在这本书中,Lea深入探讨了Java NIO(非阻塞IO)和Reactor设计模式之间的关系,并且解释了如何通过它们来构建可扩展的...
文件标题和描述提到了Java中的可伸缩IO(Scalable IO in Java),文档的标签为“nio”,即Java的非阻塞IO(New I/O),这是Java在1.4版本中引入的一个新的包java.nio,为IO提供了一种新的方式。 首先,文档提到了...
《Doug Lea Scalable IO in Java》是一本深入探讨Java NIO(非阻塞I/O)和反应器设计模式的经典著作。作者Doug Lea是Java并发领域的权威,他对Java性能优化和系统设计有着深刻的洞察力。这本书对于理解如何在Java...
在深入探讨《Scalable IO in Java》的中文版内容之前,首先需要了解Java中的I/O模型发展历程及其在服务器编程中的重要性。在Java中,I/O处理经历了从传统的BIO(阻塞I/O),到NIO(非阻塞I/O),再到AIO(异步I/O)...
《Scalable IO in Java by Doug Lea》是Java NIO领域的经典文献,由Java并发包(java.util.concurrent)的设计者Doug Lea撰写。NIO,全称非阻塞输入/输出(Non-blocking Input/Output),是Java平台从1.4版本开始引入...
Scalable IO in Java 关注的是在网络服务场景下如何实现高效、可扩展的输入输出处理。在Java中,尤其在处理高并发的网络连接时,传统的阻塞IO模型(如基于`java.io`的`ServerSocket`)可能会成为性能瓶颈,因为它会...
总结来看,Scalable IO in Java一文深入阐述了如何通过反应器模式和事件驱动的处理来构建可扩展的Java网络服务。文章强调了在系统设计中采用分而治之的策略来实现服务的水平和垂直扩展,同时保证系统在面对高负载和...
在服务端,注册服务对某个端口进行监听,然后使用阻塞的accept()函数,来取出请求队列中的socket,或者一直等待,直到收到客户端的请求。连接建立后,服务端接受输入流进行处理,返回结果给客户端。...