netty4.0.x源码分析—write和flush

最新推荐文章于 2024-06-11 17:07:22 发布

追寻北极

最新推荐文章于 2024-06-11 17:07:22 发布

阅读量678

点赞数

分类专栏： nio

nio 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

一般的开发者write和flush数据，都是基于ChannelHandlerContext ctx，然后调用其相应的write和flush方法。下面分别对这两个方法进行代码分析。（这里顺便提示一下，这两个方法都是从应用往底层发数据，属于OutboundHandler类型。如果没有特别的需求，我们不需要定义自己的handler，可以使用默认的Handler，这个在后面的分析中会体现。）

1、write方法

下面是ChannelHandlerContext的具体类DefaultChannelHandlerContext中write的相关代码

[java] view plain copy

@Override
public ChannelFuture write(Object msg) {
return write(msg, newPromise()); //构造了一个newPromise对象，调用带promise的write方法，
}
@Override
public ChannelFuture write(final Object msg, final ChannelPromise promise) {
if (msg == null) {
throw new NullPointerException("msg");
}
validatePromise(promise, true);//验证promise
write(msg, false, promise);//再一次调用write方法，flush参数设置为false，这个参数比较重要，真正的数据发送过程是flush，后面会提到
return promise;
}
private void write(Object msg, boolean flush, ChannelPromise promise) {
DefaultChannelHandlerContext next = findContextOutbound();
EventExecutor executor = next.executor();
if (executor.inEventLoop()) {
next.invokeWrite(msg, promise);//调用invokeWrite函数
if (flush) {
next.invokeFlush();
}
} else {
int size = channel.estimatorHandle().size(msg);
if (size > 0) {
ChannelOutboundBuffer buffer = channel.unsafe().outboundBuffer();
// Check for null as it may be set to null if the channel is closed already
if (buffer != null) {
buffer.incrementPendingOutboundBytes(size, false);
}
}
executor.execute(WriteTask.newInstance(next, msg, size, flush, promise));
}
}
pre name="code" class="java"> private void invokeWrite(Object msg, ChannelPromise promise) {
try {
((ChannelOutboundHandler) handler).write(this, msg, promise);//调用handler的write方法，这里我们使用HeadHandler默认的Handler方法。
} catch (Throwable t) {
notifyOutboundHandlerException(t, promise);
}
}

下面再看HeadHandler类的write方法

[java] view plain copy

@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
unsafe.write(msg, promise);
}

还记得之前，我们提到的unsafe对象吗，从这个代码中，我们可以看出unsafe对象的重要性了，真正的“苦力”还是unsafe对象啊，所以不容忽视它，赶紧来看看它的实现，下面是unsafe的write方法，主要unsafe是一个接口，下面又多个扩展的具体类，这里的write方法在protected abstract class AbstractUnsafe中定义，注意它是AbstractChannel的一个内部类。下面就是write的定义。

[java] view plain copy

@Override
public void write(Object msg, ChannelPromise promise) {
if (!isActive()) {
// Mark the write request as failure if the channel is inactive.
if (isOpen()) {
promise.tryFailure(NOT_YET_CONNECTED_EXCEPTION);
} else {
promise.tryFailure(CLOSED_CHANNEL_EXCEPTION);
}
// release message now to prevent resource-leak
ReferenceCountUtil.release(msg);
} else {
outboundBuffer.addMessage(msg, promise);
}
}

通过这个代码，我们可以清楚的看到，其实write的过程，只是把数据写入了一个buffer中，并没有真正的发送。真正的发送过程是我们后面要分析的flush的过程，好吧赶紧看看flush的过程。

2、flush方法

上面讲到flush是真正的发送数据的过程，所以这个方法还是比较关键的。先来看看DefaultChannelHandlerContext中的相关代码：

[java] view plain copy

@Override
public ChannelHandlerContext flush() {
final DefaultChannelHandlerContext next = findContextOutbound();
EventExecutor executor = next.executor();
if (executor.inEventLoop()) {
next.invokeFlush();
} else {
Runnable task = next.invokeFlushTask;
if (task == null) {
next.invokeFlushTask = task = new Runnable() {
@Override
public void run() {
next.invokeFlush();
}
};
}
executor.execute(task);
}
return this;
}
private void invokeFlush() {
try {
((ChannelOutboundHandler) handler).flush(this);
} catch (Throwable t) {
notifyHandlerException(t);
}
}

这个代码逻辑还是比较清晰的，还是我们之前分析的最终调用默认的HeadHandler来处理flush，下面是HeadHandler的flush定义。

[java] view plain copy

@Override
public void flush(ChannelHandlerContext ctx) throws Exception {
unsafe.flush();
}

这里又是unsafe这个苦力，在做事情。那就看看unsafe中flush的定义吧，仍然是在protected abstract class AbstractUnsafe中定义的，注意它是AbstractChannel的一个内部类。

[java] view plain copy

@Override
public void flush() {
ChannelOutboundBuffer outboundBuffer = this.outboundBuffer;
if (outboundBuffer == null) {
return;
}
outboundBuffer.addFlush();
flush0();
}
protected void flush0() {
if (inFlush0) {
// Avoid re-entrance
return;
}
final ChannelOutboundBuffer outboundBuffer = this.outboundBuffer;
if (outboundBuffer == null || outboundBuffer.isEmpty()) {
return;
}
inFlush0 = true;
// Mark all pending write requests as failure if the channel is inactive.
if (!isActive()) {
try {
if (isOpen()) {
outboundBuffer.failFlushed(NOT_YET_CONNECTED_EXCEPTION);
} else {
outboundBuffer.failFlushed(CLOSED_CHANNEL_EXCEPTION);
}
} finally {
inFlush0 = false;
}
return;
}
try {
doWrite(outboundBuffer);
} catch (Throwable t) {
outboundBuffer.failFlushed(t);
if (t instanceof IOException) {
close(voidPromise());
}
} finally {
inFlush0 = false;
}
}

逻辑仍然很简单，我们看到这里它最终是调用了doWrite函数，而且以buffer作参数，这个buffer其实就是write时数据存储的地方。write的过程这是就要和Channel打交道了，还记得之前我们分析过的channel吗，这里write定义在AbstractNioByteChannel类中（Server端以字节的形式发送数据），下面是具体的代码：

[java] view plain copy

@Override
protected void doWrite(ChannelOutboundBuffer in) throws Exception {
int writeSpinCount = -1;
for (;;) {
Object msg = in.current();
if (msg == null) {
// Wrote all messages.
clearOpWrite();
break;
}
if (msg instanceof ByteBuf) {
ByteBuf buf = (ByteBuf) msg;
int readableBytes = buf.readableBytes();
if (readableBytes == 0) {
in.remove();
continue;
}
if (!buf.isDirect()) {
ByteBufAllocator alloc = alloc();
if (alloc.isDirectBufferPooled()) {
// Non-direct buffers are copied into JDK's own internal direct buffer on every I/O.
// We can do a better job by using our pooled allocator. If the current allocator does not
// pool a direct buffer, we rely on JDK's direct buffer pool.
buf = alloc.directBuffer(readableBytes).writeBytes(buf);
in.current(buf);
}
}
boolean done = false;
long flushedAmount = 0;
if (writeSpinCount == -1) {
writeSpinCount = config().getWriteSpinCount();
}
for (int i = writeSpinCount - 1; i >= 0; i --) {
int localFlushedAmount = doWriteBytes(buf);
if (localFlushedAmount == 0) {
break;
}
flushedAmount += localFlushedAmount;
if (!buf.isReadable()) {
done = true;
break;
}
}
in.progress(flushedAmount);
if (done) {
in.remove();
} else {
// Did not write completely.
setOpWrite();
break;
}
} else if (msg instanceof FileRegion) {
FileRegion region = (FileRegion) msg;
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) {
break;
}
flushedAmount += localFlushedAmount;
if (region.transfered() >= region.count()) {
done = true;
break;
}
}
in.progress(flushedAmount);
if (done) {
in.remove();
} else {
// Did not write completely.
setOpWrite();
break;
}
} else {
throw new UnsupportedOperationException("unsupported message type: " + StringUtil.simpleClassName(msg));
}
}
}

从上面的代码逻辑，我们看到了最终write可能调用两个函数，一个是doWriteBytes，一个是doWriteFileRegion，这里先介绍doWriteBytes，后面有时间再介绍doWriteFileRegion。好了，我们继续看doWriteBytes这个函数的实现。它被定义在NioSocketChannel中，这是我们用来处理客户端连接常用的Channel。

[java] view plain copy

@Override
protected int doWriteBytes(ByteBuf buf) throws Exception {
final int expectedWrittenBytes = buf.readableBytes();
final int writtenBytes = buf.readBytes(javaChannel(), expectedWrittenBytes);
return writtenBytes;
}

上面的代码最终调用了buf.readBytes(channel, bytes)函数，其实这里已经开始调用真正的JDK的Socket Channel开始发送数据了。我们还是来简单的看看这个函数，后面有时间再详细介绍ByteBuf整个结构。直接上代码，这两个函数分别定义在AbstractByteBuf类和ReadOnlyByteBufferBuf中，可以看出最终就是通过JDK的channel.write函数进行数据发送。

[java] view plain copy

@Override
public int readBytes(GatheringByteChannel out, int length)
throws IOException {
checkReadableBytes(length);
int readBytes = getBytes(readerIndex, out, length);
readerIndex += readBytes;
return readBytes;
}
@Override
public int getBytes(int index, GatheringByteChannel out, int length) throws IOException {
ensureAccessible();
if (length == 0) {
return 0;
}
ByteBuffer tmpBuf = internalNioBuffer();
tmpBuf.clear().position(index).limit(index + length);
return out.write(tmpBuf);
}