netty（五） channel

问题

• channel 是如何处理发送一半中断后继续重发的
• channel 具体作用是什么

概述

这一节我们将介绍 Channel 和内部接口 Unsafe .其中Unsafe 是内部接口，聚合在Channel 中协助网络读写操作相关的操作，设计初衷就是 Channel 的内部辅助类，不应该被用户使用。

继承类分析

继承关系链 ：

AbstractChannel -> AbstractNioChannel -> AbstractNioByteChannel -> NioSocketChannel 如下图

从以上的类结构我们也要学习一下类的构建，各个类实现应该实现的功能，最后生成的具体类具有不同的功能。
AbstractChannel ，保存以下重要的字段 ，主要
- EventLoop
- localAddress
- remoteAddress
- unsafe
- DefaultChannelPipleline
- Future类 和 Promise类 等

AbstractNioChannel，从类名可以看出和nio 中 Channel 相关，注册，监听

    private final SelectableChannel ch;
    protected final int readInterestOp;
    private volatile SelectionKey selectionKey;
    private volatile boolean inputShutdown;

    /**
     * The future of the current connection attempt.  If not null, subsequent
     * connection attempts will fail.
     */
    private ChannelPromise connectPromise;
    private ScheduledFuture<?> connectTimeoutFuture;
    private SocketAddress requestedRemoteAddress;

 AbstractNioByteChannel 这个类是Channel对Byte进行操作，对ByteBuff的读写。

源码分析

AbstractChannel

AbstractChannel 的读写方法都是交由 ChannelPiple 来解决的

    @Override
    public Channel read() {
        pipeline.read();
        return this;
    }

    @Override
    public ChannelFuture write(Object msg) {
        return pipeline.write(msg);
    }

eventLoop方法，直接返回持有的 eventloop对象

    @Override
    public EventLoop eventLoop() {
        return eventLoop;
    }

AbstractNioChannel

public abstract class AbstractNioChannel extends AbstractChannel {

    private static final InternalLogger logger =
            InternalLoggerFactory.getInstance(AbstractNioChannel.class);

    // No.1 注册监听相关的字段
    private final SelectableChannel ch;
    protected final int readInterestOp;
    private volatile SelectionKey selectionKey;
    private volatile boolean inputShutdown;

    // No.2 异步执行的字段，或是回调相关的字段
    /**
     * The future of the current connection attempt.  If not null, subsequent
     * connection attempts will fail.
     */
    private ChannelPromise connectPromise;
    private ScheduledFuture<?> connectTimeoutFuture;
    private SocketAddress requestedRemoteAddress;

    ...

    //核心方法
    @Override
    protected void doRegister() throws Exception {
        boolean selected = false;
        for (;;) {
            try {
            	//拿父类的channel对象（父类的channel对象是java原生channel 对象）
                selectionKey = javaChannel().register(eventLoop().selector, 0, this);
                return;
            } catch (CancelledKeyException e) {
                if (!selected) {
                    // Force the Selector to select now as the "canceled" SelectionKey may still be
                    // cached and not removed because no Select.select(..) operation was called yet.
                    eventLoop().selectNow();
                    selected = true;
                } else {
                    // We forced a select operation on the selector before but the SelectionKey is still cached
                    // for whatever reason. JDK bug ?
                    throw e;
                }
            }
        }
    }

    //开始read的操作
    @Override
    protected void doBeginRead() throws Exception {
        if (inputShutdown) {
            return;
        }

        final SelectionKey selectionKey = this.selectionKey;
        if (!selectionKey.isValid()) {
            return;
        }

        //就是改变监听的事件
        final int interestOps = selectionKey.interestOps();
        if ((interestOps & readInterestOp) == 0) {
            selectionKey.interestOps(interestOps | readInterestOp);
        }
    }

AbstractNioByteChannel

    @Override
    protected void doWrite(ChannelOutboundBuffer in) throws Exception {
        int writeSpinCount = -1;

        //循环
        for (;;) {
            Object msg = in.current(true);

            if (msg == null) {
                // Wrote all messages.写完了（发送完了）所有的消息，清除标志，结束
                clearOpWrite();
                break;
            }

            if (msg instanceof ByteBuf) {
                //加入是ByteBuf类型
                ByteBuf buf = (ByteBuf) msg;
                int readableBytes = buf.readableBytes();
                //判断当前的可读字节是否为 0 ，为 0 丢弃掉
                if (readableBytes == 0) {
                    in.remove();
                    continue;
                }

                boolean setOpWrite = false;
                boolean done = false;
                long flushedAmount = 0;
                //循环发送次数
                if (writeSpinCount == -1) {
                    writeSpinCount = config().getWriteSpinCount();
                }
                for (int i = writeSpinCount - 1; i >= 0; i --) {
                    //doWriteBytes 子类实现
                    int localFlushedAmount = doWriteBytes(buf);
                    if (localFlushedAmount == 0) {
                        setOpWrite = true;
                        break;
                    }

                    flushedAmount += localFlushedAmount;
                    //一直到不可读
                    if (!buf.isReadable()) {
                        done = true;
                        break;
                    }
                }
                //发送完，更新发送的进度（有可能没发完）
                in.progress(flushedAmount);

                if (done) {
                    in.remove();
                } else {
                    //没发完，设置写半包标识，启动刷新线程继续发送之前没有发送完成的半包消息
                    incompleteWrite(setOpWrite);
                    break;
                }
            } else if (msg instanceof FileRegion) {
                FileRegion region = (FileRegion) msg;
                boolean setOpWrite = false;
                boolean done = false;
                long flushedAmount = 0;
                if (writeSpinCount == -1) {
                    writeSpinCount = config().getWriteSpinCount();
                }

                //循环发送
                for (int i = writeSpinCount - 1; i >= 0; i --) {
                    long localFlushedAmount = doWriteFileRegion(region);
                    if (localFlushedAmount == 0) {
                        setOpWrite = true;
                        break;
                    }

                    flushedAmount += localFlushedAmount;
                    if (region.transfered() >= region.count()) {
                        done = true;
                        break;
                    }
                }
                //发送完（有可能发送了一半）更新进度
                in.progress(flushedAmount);

                if (done) {
                    in.remove();
                } else {
                    //没法完，创建一个任务扔到EventLoop
                    incompleteWrite(setOpWrite);
                    break;
                }
            } else {
                throw new UnsupportedOperationException("unsupported message type: " + StringUtil.simpleClassName(msg));
            }
        }
    }

    //没写完（没发送完）
    protected final void incompleteWrite(boolean setOpWrite) {
        // Did not write completely.
        if (setOpWrite) {
            setOpWrite();
        } else {
            // Schedule flush again later so other tasks can be picked up in the meantime
            //创建任务扔到 eventLoop执行
            Runnable flushTask = this.flushTask;
            if (flushTask == null) {
                flushTask = this.flushTask = new Runnable() {
                    @Override
                    public void run() {
                        flush();
                    }
                };
            }
            eventLoop().execute(flushTask);
        }
    }

循环发送次数是指一次发送没有完成时（写半包），程序就继续尝试循环写操作，此时IO线程是不能处理其他事件的，例如读新的消息或者执行定时任务和 NioTask 等， 如果网络IO阻塞或者对方接收消息太慢，可能会导致线程假死，于是就要循环发送。

AbstractNioMessageChannel

我们再来看一下AbstractNioChannel 的另外一个子类 AbstractNioMessageChannel，直接看doWrite方法

    @Override
    protected void doWrite(ChannelOutboundBuffer in) throws Exception {
        final SelectionKey key = selectionKey();
        final int interestOps = key.interestOps();

        for (;;) {
            Object msg = in.current();
            if (msg == null) {
                // Wrote all messages.
                if ((interestOps & SelectionKey.OP_WRITE) != 0) {
                    key.interestOps(interestOps & ~SelectionKey.OP_WRITE);
                }
                break;
            }

            boolean done = false;
            for (int i = config().getWriteSpinCount() - 1; i >= 0; i --) {
                if (doWriteMessage(msg, in)) {
                    done = true;
                    break;
                }
            }

            if (done) {
                in.remove();
            } else {
                // Did not write all messages.
                //没发送完,设置标志，交给 select 多路复用器轮询对应的channel重新发送尚未发送完成的半包信息
                if ((interestOps & SelectionKey.OP_WRITE) == 0) {
                    key.interestOps(interestOps | SelectionKey.OP_WRITE);
                }
                break;
            }
        }
    }

AbstractNioMessageChannel 和 AbstractNioByteChannel的区别在于

NioServerSocketChannel 和 NioServerChannel 的分析

NioSocketChannel 和 NioServerSocketChannel 的区别到底是什么？后者是服务端当中负责绑定端口，读取数据功能，连接和断开，写消息都不支持，这些功能都在NioSocketChannel中实现

AbstractNioMessageServerChannel 的具体子类是 NioServerSocketChannel（该类是服务器端接受处理客户端的channel），它的doReadMessages方法（被对应的unsafe类read方法，这里可能有点饶，具体看代码实现）分析如下

	@Override
    protected int doReadMessages(List<Object> buf) throws Exception {
        SocketChannel ch = javaChannel().accept();

        try {
            if (ch != null) {
            	//构建一个NioSocketChannel放进数组中
                buf.add(new NioSocketChannel(this, childEventLoopGroup().next(), ch));
                return 1;
            }
        } catch (Throwable t) {
            logger.warn("Failed to create a new channel from an accepted socket.", t);

            try {
                ch.close();
            } catch (Throwable t2) {
                logger.warn("Failed to close a socket.", t2);
            }
        }

        return 0;
    }

NioServerChannel的源码分析

public class NioServerSocketChannel extends AbstractNioMessageServerChannel
                                 implements io.netty.channel.socket.ServerSocketChannel {

    private static final ChannelMetadata METADATA = new ChannelMetadata(false);

    private static final InternalLogger logger = InternalLoggerFactory.getInstance(NioServerSocketChannel.class);

    private static ServerSocketChannel newSocket() {
        try {
            return ServerSocketChannel.open();
        } catch (IOException e) {
            throw new ChannelException(
                    "Failed to open a server socket.", e);
        }
    }

    private final ServerSocketChannelConfig config;

    /**
     * Create a new instance
     */
    public NioServerSocketChannel(EventLoop eventLoop, EventLoopGroup childGroup) {
        super(null, eventLoop, childGroup, newSocket(), SelectionKey.OP_ACCEPT);
        config = new DefaultServerSocketChannelConfig(this, javaChannel().socket());
    }

    @Override
    public InetSocketAddress localAddress() {
        return (InetSocketAddress) super.localAddress();
    }

    @Override
    public ChannelMetadata metadata() {
        return METADATA;
    }

    @Override
    public ServerSocketChannelConfig config() {
        return config;
    }

    @Override
    public boolean isActive() {
        return javaChannel().socket().isBound();
    }

    @Override
    public InetSocketAddress remoteAddress() {
        return null;
    }

    @Override
    protected ServerSocketChannel javaChannel() {
        return (ServerSocketChannel) super.javaChannel();
    }

    @Override
    protected SocketAddress localAddress0() {
        return javaChannel().socket().getLocalSocketAddress();
    }

    @Override
    protected void doBind(SocketAddress localAddress) throws Exception {
        javaChannel().socket().bind(localAddress, config.getBacklog());
    }

    @Override
    protected void doClose() throws Exception {
        javaChannel().close();
    }

    @Override
    protected int doReadMessages(List<Object> buf) throws Exception {
        SocketChannel ch = javaChannel().accept();

        try {
            if (ch != null) {
                buf.add(new NioSocketChannel(this, childEventLoopGroup().next(), ch));
                return 1;
            }
        } catch (Throwable t) {
            logger.warn("Failed to create a new channel from an accepted socket.", t);

            try {
                ch.close();
            } catch (Throwable t2) {
                logger.warn("Failed to close a socket.", t2);
            }
        }

        return 0;
    }

    // Unnecessary stuff
    @Override
    protected boolean doConnect(
            SocketAddress remoteAddress, SocketAddress localAddress) throws Exception {
        throw new UnsupportedOperationException();
    }

    @Override
    protected void doFinishConnect() throws Exception {
        throw new UnsupportedOperationException();
    }

    @Override
    protected SocketAddress remoteAddress0() {
        return null;
    }

    @Override
    protected void doDisconnect() throws Exception {
        throw new UnsupportedOperationException();
    }

    @Override
    protected boolean doWriteMessage(Object msg, ChannelOutboundBuffer in) throws Exception {
        throw new UnsupportedOperationException();
    }
}

可以看到 NioServerChannel 的主要都是 override 父类的方法，即是说大部分的逻辑都在父类 Abstract中进行了一层层的封装，给我们一个启发，好的类结构在
在一开始就已经设计好，最终的具体实现交由尾端实现。

总结

本文介绍了channel的主要功能作用。

参考资料

• 《Netty权威指南》