加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 (https://www.lidatong.com.cn/)- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置: 首页 > 百科 > 正文

Reactor模式和NIO

发布时间:2020-12-15 05:24:00 所属栏目:百科 来源:网络整理
导读:当前 分布式 计算 Web Services盛行天下,这些网络服务的底层都离不开对socket的操作。他们都有一个共同的结构: 1. Read request 2. Decode request 3. Process service 4. Encode reply 5. Send reply 经典的 网络服务 的 设计 如下图,在每个线程中完成对

当前分布式计算 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模式代码:


import java.io.IOException;
 java.net.InetAddress;
 java.net.InetSocketAddress;
 java.nio.channels.SelectionKey;
 java.nio.channels.Selector;
 java.nio.channels.ServerSocketChannel;
 java.util.Iterator;
 java.util.Set;

/**
 * 反应器模式 用于解决多用户访问并发问题
 * 
 * 举个例子:餐厅服务问题
 * 
 * 传统线程池做法:来一个客人(请求)去一个服务员(线程)
 * 反应器模式做法:当客人点菜的时候,服务员就可以去招呼其他客人了,等客人点好了菜,直接招呼一声:服务员
 * 
 * @author linxcool
 */
public class Reactor implements Runnable {
    final Selector selector;
     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
    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
     */
     dispatch(SelectionKey key) {
        Runnable r = (Runnable) (key.attachment());
        if (r != null) {
            r.run();
        }
    }

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


注意在Handler里面又执行了一次attach,这样,覆盖前面的Acceptor,下次该Handler又有READ事件发生时,将直接触发Handler.从而开始了数据的读 处理 写 发出等流程处理。


将数据读出后,可以将这些数据处理线程做成一个线程池,这样,数据读出后,立即扔到线程池中,这样加速处理速度:

更进一步,我们可以使用多个Selector分别处理连接和读事件。

一个高性能的Java网络服务机制就要形成,激动人心的集群并行计算即将实现。

(编辑:李大同)

【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!

    推荐文章
      热点阅读