发送数据:自适应写和连接写同样是为了解决什么问题

发送数据:自适应写和连接写同样是为了解决什么问题

Netty 系列目录(https://www.cnblogs.com/binarylei/p/10117436.html)

发送数据和接收数据比较类似,可以将这两部分结合起来学习。 接收数据:自适应缓冲区和连接读是为了解决什么问题

1. 主线分析

1.1 写数据要点

和读数据一样,写数据我们也会碰到以下问题:

  1. 每次写多少数据合适,这就是自适应写。
  2. 如何处理高并发,保证雨露均沾,这就是连续写。
  3. 不能写了怎么办,这就需要注册 OP_WRITE 事件。

我们再看一下,Netty 是如何解决这几个问题的。这部分才是本小节内容的核心。

  1. 自适应写(maxBytesPerGatheringWrite)

    Netty 批量写数据时,如果想写的都写进去了,接下来的尝试写更多(调整 maxBytesPerGatheringWrite)。

  2. 连续写(writeSpinCount)

    同连接读一样,每个连接默认最多连续写 16 次,即使还有数据也暂时不处理了,先处理下一个连接。

  3. 注册 OP_WRITE 事件

    如果 socket sendbuf 已经写不动,那就注册 OP_WRITE 事件。当触发 OP_WRITE 事件时,则取消 OP_WRITE 事件,并继续写。

  4. 高低水位线(writeBufferWaterMark)

    Netty 待写数据太多,超过一定的水位线(writeBufferWaterMark.high()),会将可写的标志位改成
    false ,让应用自己做决定要不要发送数据了。

1.2 主线

Netty 中将发送数据分为两步,write 只写到缓冲区,只有调用 flush 才会真正发送数据。

  • Write:写数据到 buffer,ChannelOutboundBuffer#addMessage
  • Flush:发送 buffer 里面的数据,AbstractChannel.AbstractUnsafe#flush
    • 准备数据:ChannelOutboundBuffer#addFlush
    • 发送:NioSocketChannel#doWrite

发送数据核心步骤有三步:addMessage、addFlush、doWrite。如下图所示:

图1:发送数据分为两步:写缓冲区和刷新

1.2 知识点

(1)写的本质

  • Single write: sun.nio.ch.SocketChannelImpl#write(java.nio.ByteBuffer)
  • Gathering write:sun.nio.ch.SocketChannelImpl#write(java.nio.ByteBuffer[], int, int)

(2)OP_WRITE vs OP_READ

  • OP_WRITE:调用 ch.unsafe().forceFlush() 刷新数据到 socket sendbuf 缓冲区。正常情况下不能注册,否则一直触发该事件。我们只是需要一个机制,在能写时通知程序可以继续写就可以了。
  • OP_READ:一直注册,只要有数据就读,读超过 defaultMaxMessagesPerRead 次则下次继续读。

(3)写优化

  • 自适应写:批量写数据时,如果尝试写的都写进去了,接下来会尝试写更多(maxBytesPerGatheringWrite)。
  • 连续写:最多写 16 次(writeSpinCount),如果没有写完,就直接 schedule 一个 task 来继续写,而不是用注册写事件来触发,更简洁有力。
  • 水位线:待写数据太多,超过水位线 writeBufferWaterMark.high(),会将可写的标志位改成 false ,让应用端自己做决定要不要继续写。
    • ctx.channel().write() :从 TailContext 开始执行;
    • ctx.write() : 从当前的 Context 开始。

2. 源码分析

ctx#write
    -> HeadContext#write
        -> AbstractChannel.AbstractUnsafe#write
            -> ChannelOutboundBuffer#addMessage    # √ 添加到缓冲区
ctx#flush
    -> HeadContext#flush
        -> AbstractChannel.AbstractUnsafe#flush
            -> ChannelOutboundBuffer#addFlush      # √ 将缓冲区的数据状态改成待发送状态
            -> flush0
                -> NioSocketChannel#doWrite        # √ 核心逻辑,真正发送数据

ChannelOutboundBuffer 缓冲区本质是一个单向链表,addMessage、addFlush、doWrite 会更新链表的状态。

private Entry flushedEntry;     // 相当于队头。doWrite时将发送数据后并更新
private Entry unflushedEntry;   // 指向第一个未刷新的数据。addFlush时更新
private Entry tailEntry;        // 队尾。addMessage 添加到队尾并更新
private int flushed;            // 表示flushedEntry~unflushedEntry中未刷新结点的个数

说明: addFlush 更新 unflushedEntry 后,并不表示链表之前的缓冲区数据已经发送。只有调用 doWrite 才真正发送数据,并更新 flushedEntry,将结点从缓冲区中剔除。

2.1 addMessage

ctx#write 调用 addMessage 方法将 msg 添加到缓冲区。addMessage 完成了二件事:

  1. 将 msg 包装成 Entry,添加到 outboundBuffer 队尾。
  2. 判断是否超过缓冲区的高水位线,如果超过将可写标志设置为 false。如果应用程序不管三七二十一继续写,可能发生 OOM。
public void addMessage(Object msg, int size, ChannelPromise promise) {
    // 1. 添加到队尾,更新tailEntry
    Entry entry = Entry.newInstance(msg, size, total(msg), promise);
    if (tailEntry == null) {
        flushedEntry = null;
    } else {
        Entry tail = tailEntry;
        tail.next = entry;
    }
    tailEntry = entry;
    if (unflushedEntry == null) {
        unflushedEntry = entry;
    }

    // 2. 如果超过高水位线,将可写标志设置为false 
    incrementPendingOutboundBytes(entry.pendingSize, false);
}

说明: addMessage 的参数 size 为 msg 的大小,Netty 默认使用 DefaultMessageSizeEstimator,直接调用 ((ByteBuf) msg).readableBytes() 获取数据包的大小。高低水位线最后再来统一分析。

2.2 addFlush

ctx#flush 先调用 addFlush 更新 unflushedEntry,然后调用 unsafe.flush0() 将 flushedEntry ~ unflushedEntry 之间的数据刷新出去。addFlush 同样做了两件事:

  1. 更新 unflushedEntry 到队尾。
  2. 如果有结点 cancel 则重新判断水位线,是否将可写标志设置为 true。
public void addFlush() {
    Entry entry = unflushedEntry;
    if (entry != null) {
        if (flushedEntry == null) 
            flushedEntry = entry;
        }
        do {
            flushed ++;
            if (!entry.promise.setUncancellable()) {
                int pending = entry.cancel();
                decrementPendingOutboundBytes(pending, false, true);
            }
            entry = entry.next;
        } while (entry != null);
        unflushedEntry = null;
    }
}

2.3 doWrite

unsafe.flush0() 实际上是调用 NioSocketChannel#doWrite 方法,将 flushedEntry ~ unflushedEntry 之间的数据刷新出去,同时更新 flushedEntry。这也是最复杂的一部分。doWrite 方法:

  1. writeSpinCount:连续写的最大次数,这个就再赘述了。
  2. 缓冲区为空:直接返回,同时取消 OP_WRITE 事件的注册。前面已经提到,OP_WRITE 事件其实上是调用 flush 将缓冲区的数据刷新出去,都没有数据了,当然也就不需要了。此时不会调用 incompleteWrite 方法。
  3. 将缓冲区的数据转换成 ByteBuffer(方便后面调用 API):每次最多写 maxBytesPerGatheringWrite,每次刷新时会调整 maxBytesPerGatheringWrite 值。
  4. 缓冲区有数据:按缓冲区 in 转换成 ByteBuffer[] 的数据长度分三种情况。
    • 长度为 0:表示要写的数据不是 ByteBuf,如 FileRegin。直接调用 doWrite0() 方法,本质和 ByteBuf 差不多,这里不会分析这种情况。
    • 长度为 1 或大于 1:其实这两种情况差不多,长度为 1 时调用 ch.write(buffer),长度大于 1 时调用 ch.write(nioBuffers, 0, nioBufferCnt),也就批量写。在这里我们只分析长度大于 1 的情况。
  5. 什么时候结束刷新操作(incompleteWrite)
    • 写次数超过 writeSpinCount:退出循环时 writeSpinCount = 0,即调用 incompleteWrite(false) 方法,注册一个 flushTask,flushTask 其实也是直接调用 unsafe().flush0(),空闲时继续刷新。
    • socket sendbuf 刷不动了:调用 incompleteWrite(true),注册 OP_WRITE 事件,等触发该事件后继续刷新。
    • 数据写完:即从第二步退出循环,同时取消 OP_WRITE 事件注册。此时不会调用 incompleteWrite 方法,incompleteWrite 从方法名称也知道当数据没有刷新完时调用。
NioSocketChannel#doWrite
    -> ChannelOutboundBuffer#nioBuffers       # 将in中待刷新的数据转换成ByteBuffer[]
    -> SocketChannel#write                    # 真正刷新数据
    -> adjustMaxBytesPerGatheringWrite        # 动态调整下一次刷新的数据
    -> ChannelOutboundBuffer#removeBytes      # 将in中已经刷新的结点移除
    -> AbstractNioByteChannel#incompleteWrite # 处理未全部刷新完成的情况
    -> AbstractNioByteChannel#clearOpWrite    # 清除 OP_WRITE 事件

doWrite 代码如下(有删减)

@Override
protected void doWrite(ChannelOutboundBuffer in) throws Exception {
    // 1. 将缓冲区in中的数据转换成ByteBuffer[]
    int maxBytesPerGatheringWrite = ((NioSocketChannelConfig) config).getMaxBytesPerGatheringWrite();
    ByteBuffer[] nioBuffers = in.nioBuffers(1024, maxBytesPerGatheringWrite);
    int nioBufferCnt = in.nioBufferCount();

    // do...while 刷新缓冲区数据
    long attemptedBytes = in.nioBufferSize();
    // 2. socket api 刷新数据
    final long localWrittenBytes = ch.write(nioBuffers, 0, nioBufferCnt);
    // 3. socket sendbuf 刷不动后,调用incompleteWrite,并结点刷新
    if (localWrittenBytes <= 0) {
        incompleteWrite(true);
        return;
    }
    // 4. 动态调整每次最大刷新的数据量
    adjustMaxBytesPerGatheringWrite((int) attemptedBytes, (int) localWrittenBytes, maxBytesPerGatheringWrite);
    // 5. 删除in中已经刷新的数据结点
    in.removeBytes(localWrittenBytes);
}

说明: in.nioBuffers 和 in.removeBytes 都是 ChannelOutboundBuffer 的操作,先不去管它。我们看一下,adjustMaxBytesPerGatheringWrite 和 incompleteWrite 这两个方法都做了些什么事。

(1)adjustMaxBytesPerGatheringWrite

// maxBytesPerGatheringWrite:默认是SO_SNDBUF大小
// attempted表示尝试刷新的数据大小,而written表示真实刷新的数据大小。
private void adjustMaxBytesPerGatheringWrite(int attempted, int written, int oldMaxBytesPerGatheringWrite) {
    // 1. 扩大2倍。全部写满了,可能还有更多的数据需要写。
    if (attempted == written) {
        if (attempted << 1 > oldMaxBytesPerGatheringWrite) {
            ((NioSocketChannelConfig) config).setMaxBytesPerGatheringWrite(attempted << 1);
        }
    // 2. 缩小2倍。attempted>4KB且真实写入的数据不到attempted的一半
    } else if (attempted > MAX_BYTES_PER_GATHERING_WRITE_ATTEMPTED_LOW_THRESHOLD && written < attempted >>> 1) {
        ((NioSocketChannelConfig) config).setMaxBytesPerGatheringWrite(attempted >>> 1);
    }
}

(2)incompleteWrite

incompleteWrite 表示数据没有写完,又分两种情况:true 表示 socket sendbuf 写不了;false 表示连续写次数超过16次,提交flushTask,空闲时继续写。

protected final void incompleteWrite(boolean setOpWrite) {
    // 1. socket sendbuf 写不了
    if (setOpWrite) {
        setOpWrite();
    // 2. 连续写次数超过16次,提交flushTask,空闲时继续写
    } else {
        clearOpWrite();
        eventLoop().execute(flushTask);
    }
}

2.4 ChannelOutboundBuffer

  • addMessage:将 msg 添加到缓冲区。
  • addFlush:更新 unflushedEntry,flushedEntry ~ unflushedEntry 之间的结点表示需要刷新的数据。
  • nioBuffers:将可刷新缓冲区的数据转换成 ByteBuffer[]。
  • removeBytes:删除已经刷新的结点,更新 flushedEntry。

2.5 高低水位线

WriteBufferWaterMark 中设置了默认的高低水位线,高水位线默认为 32KB,低水位线默认为 64KB。

  1. 32KB 是不是太小了。Netty 支持百万连接,如果连接过多,可能导致内存压力很大。
  2. 为什么要设置高低水位线两个阀值。避免写标志位频繁波动。
private static final int DEFAULT_LOW_WATER_MARK = 32 * 1024;
private static final int DEFAULT_HIGH_WATER_MARK = 64 * 1024;

高低水位线设置代码如下:

// 超过高水位线,可写标志设置成false
private void incrementPendingOutboundBytes(long size, boolean invokeLater) {
    long newWriteBufferSize = TOTAL_PENDING_SIZE_UPDATER.addAndGet(this, size);
    if (newWriteBufferSize > channel.config().getWriteBufferHighWaterMark()) {
        setUnwritable(invokeLater);
    }
}

// 超过低水位线,可写标志设置成true
private void decrementPendingOutboundBytes(long size, boolean invokeLater, boolean notifyWritability) {
    long newWriteBufferSize = TOTAL_PENDING_SIZE_UPDATER.addAndGet(this, -size);
    if (notifyWritability && newWriteBufferSize < channel.config().getWriteBufferLowWaterMark()) {
        setWritable(invokeLater);
    }
}

3. 总结

3.1 发送数据默认参数

  • 高水位线(high):64KB
  • 低水位线(low):32KB
  • 一次刷新数据的大小(maxBytesPerGatheringWrite):默认是 SO_SNDBUF 大小
  • 连续写最大次数(writeSpinCount):16

每天用心记录一点点。内容也许不重要,但习惯很重要!

posted on 2020-04-06 17:15  binarylei  阅读(...)  评论(...编辑  收藏

导航

统计