es 网络层

m0_37294549

已于 2022-02-13 23:57:20 修改

阅读量611

点赞数

文章标签： elasticsearch 大数据 big data

于 2022-02-13 23:23:54 首次发布

本文链接：https://blog.csdn.net/m0_37294549/article/details/122915536

版权

本文详细介绍了基于Java NIO实现RPC网络层的架构设计，包括NioSelectorGroup、NioSelector、ChannelFactory等核心组件的使用，以及如何处理RPC消息，如连接、读写操作。通过NIO的多路复用技术，实现了单线程处理多个通道的高效模型。

摘要由CSDN通过智能技术生成

1 es 基于 jdk, nio sdk 搭建 rpc 网络层

nio多路复用 :
SelectableChannel
Selector

libs/nio :

NioSelectorGroup
NioSelector
ChannelFactory
ChannelContext

plugins/transport-nio :

NioGropuFactory
NioTranport

在这里插入图片描述

2 NioSelector 处理rpc消息

每个 nio selector  单线程处理ready 状态channel
void singleLoop() {
    try {
        closePendingChannels();
        preSelect();
        long nanosUntilNextTask = taskScheduler.nanosUntilNextTask(System.nanoTime());
        int ready;
        if (nanosUntilNextTask == 0) {
            ready = selector.selectNow();
        } else {
            long millisUntilNextTask = TimeUnit.NANOSECONDS.toMillis(nanosUntilNextTask);
            // Only select until the next task needs to be run. Do not select with a value of 0 because
            // that blocks without a timeout.
            ready = selector.select(Math.min(300, Math.max(millisUntilNextTask, 1)));
        }
        if (ready > 0) {
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectionKeys.iterator();
            while (keyIterator.hasNext()) {
                SelectionKey sk = keyIterator.next();
                keyIterator.remove();
                if (sk.isValid()) {
                    try {
                        processKey(sk);
                    } catch (CancelledKeyException cke) {
                        eventHandler.genericChannelException((ChannelContext<?>) sk.attachment(),  cke);
                    }
                } else {
                    eventHandler.genericChannelException((ChannelContext<?>) sk.attachment(),  new CancelledKeyException());
                }
            }
        }

        handleScheduledTasks(System.nanoTime());
    } catch (ClosedSelectorException e) {
        if (isOpen()) {
            throw e;
        }
    } catch (IOException e) {
        eventHandler.selectorException(e);
    } catch (Exception e) {
        eventHandler.uncaughtException(e);
    }
}

处理监听，读写请求
void processKey(SelectionKey selectionKey) {
    ChannelContext<?> context = (ChannelContext<?>) selectionKey.attachment();
    if (selectionKey.isAcceptable()) {
        assert context instanceof ServerChannelContext : "Only server channels can receive accept events";
        ServerChannelContext serverChannelContext = (ServerChannelContext) context;
        int ops = selectionKey.readyOps();
        if ((ops & SelectionKey.OP_ACCEPT) != 0) {
            try {
                eventHandler.acceptChannel(serverChannelContext);
            } catch (IOException e) {
                eventHandler.acceptException(serverChannelContext, e);
            }
        }
    } else {
        assert context instanceof SocketChannelContext : "Only sockets channels can receive non-accept events";
        SocketChannelContext channelContext = (SocketChannelContext) context;
        int ops = selectionKey.readyOps();
        if ((ops & SelectionKey.OP_CONNECT) != 0) {
            attemptConnect(channelContext, true);
        }

        if (channelContext.isConnectComplete()) {
            if (channelContext.selectorShouldClose() == false) {
                if ((ops & SelectionKey.OP_WRITE) != 0) {
                    handleWrite(channelContext);
                }
                if (channelContext.selectorShouldClose() == false && (ops & SelectionKey.OP_READ) != 0) {
                    handleRead(channelContext);
                }
            }
        }
        eventHandler.postHandling(channelContext);
    }

}