Netty 源码剖析之 unSafe.write 方法

前言

在 Netty 源码剖析之 unSafe.read 方法 一文中，我们研究了 read 方法的实现，这是读取内容到容器，再看看 Netty 是如何将内容从容器输出 Channel 的吧。

1. ctx.writeAndFlush 方法

当我们调用此方法时，会从当前节点找上一个 outbound 节点，进行，并调用下个节点的 write 方法。具体看代码：

@1
public ChannelFuture writeAndFlush(Object msg) {
    return writeAndFlush(msg, newPromise()); // 创建了一个默认的 DefaultChannelPromise 实例，返回的就是这个实例。

@2
public ChannelFuture writeAndFlush(Object msg, ChannelPromise promise) {
    if (isNotValidPromise(promise, true)) {//判断 promise 有效性
        ReferenceCountUtil.release(msg);// 释放内存
        return promise;
    }

    write(msg, true, promise);

    return promise;
}

@3
private void write(Object msg, boolean flush, ChannelPromise promise) {
    AbstractChannelHandlerContext next = findContextOutbound();
    final Object m = pipeline.touch(msg, next);
    EventExecutor executor = next.executor();
    if (executor.inEventLoop()) {
        if (flush) {
            next.invokeWriteAndFlush(m, promise);
        } else {
            next.invokeWrite(m, promise);
        }
    } else {
        AbstractWriteTask task;
        if (flush) {
            task = WriteAndFlushTask.newInstance(next, m, promise);
        }  else {
            task = WriteTask.newInstance(next, m, promise);
        }
        safeExecute(executor, task, promise, m);
    }
}

最终调用的就是 @3 方法。找到上一个 outbound 节点，判断他的节点是否时当前线程。如果是，则会直接调用，泛着，将后面的工作封装成一个任务放进 mpsc 队列，供当前线程稍后执行。这个 任务的 run 方法如下：

public final void run() {
    try {
        if (ESTIMATE_TASK_SIZE_ON_SUBMIT) {
            ctx.pipeline.decrementPendingOutboundBytes(size);
        }
        write(ctx, msg, promise);
    } finally {
        ctx = null;
        msg = null;
        promise = null;
        handle.recycle(this);
    }
}

protected void write(AbstractChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
    ctx.invokeWrite(msg, promise);
}

最终执行的是 invokeWrite 方法。

我们看看如果直接执行会如何处理。

private void invokeWriteAndFlush(Object msg, ChannelPromise promise) {
    if (invokeHandler()) {
        invokeWrite0(msg, promise);
        invokeFlush0();
    } else {
        writeAndFlush(msg, promise);
    }
}

先执行 invokeWrite0 方法进行 write，然后 flush。

最终执行的是 unSafe 的 write 方法。注意：当前节点已经到了 Head 节点。

详细说说该方法。

2. unSafe 的 write 方法

public final void write(Object msg, ChannelPromise promise) {
    ChannelOutboundBuffer outboundBuffer = this.outboundBuffer;
    if (outboundBuffer == null) {
        safeSetFailure(promise, WRITE_CLOSED_CHANNEL_EXCEPTION);
        ReferenceCountUtil.release(msg);
        return;
    }

    int size;
    try {
        msg = filterOutboundMessage(msg);
        size = pipeline.estimatorHandle().size(msg);
        if (size < 0) {
            size = 0;
        }
    } catch (Throwable t) {
        safeSetFailure(promise, t);
        ReferenceCountUtil.release(msg);
        return;
    }

    outboundBuffer.addMessage(msg, size, promise);
}

方法步骤如下：

1. 判断 outboundBuffer 有效性。
2. 将 ByteBuf 过滤成池化或者线程局部直接内存（如果不是直接内存的话）。
3. 预估当前 ByteBuf 大小（就是可读字节数）。
4. 将 ByteBuf 包装成一个 Entry 节点放入到 outboundBuffer 的单向链表中。

这里有一个地方需要注意一下， filterOutboundMessage 方法。

如果是直接内存的话，就直接返回了 ，反之调用 newDirectBuffer 方法。我们猜想肯定是重新包装成直接内存，利用直接内存令拷贝的特性，提升性能。

看看该方法内部逻辑：

protected final ByteBuf newDirectBuffer(ByteBuf buf) {
    final int readableBytes = buf.readableBytes();
    if (readableBytes == 0) {
        ReferenceCountUtil.safeRelease(buf);
        return Unpooled.EMPTY_BUFFER;
    }

    final ByteBufAllocator alloc = alloc();
    if (alloc.isDirectBufferPooled()) {
        ByteBuf directBuf = alloc.directBuffer(readableBytes);
        directBuf.writeBytes(buf, buf.readerIndex(), readableBytes);
        ReferenceCountUtil.safeRelease(buf);
        return directBuf;
    }

    final ByteBuf directBuf = ByteBufUtil.threadLocalDirectBuffer();
    if (directBuf != null) {
        directBuf.writeBytes(buf, buf.readerIndex(), readableBytes);
        ReferenceCountUtil.safeRelease(buf);
        return directBuf;
    }

    // Allocating and deallocating an unpooled direct buffer is very expensive; give up.
    return buf;
}

1. 首先判断可读字节数，如果是0，之际返回一个空的 Buffer。
2. 获取该 Channel 的 ByteBufAllocator ，如果是直接内存且池化，则分配一个直接内存，将旧的 Buffer 写入到新的中，释放旧的 Buffer。返回新的直接内存 Buffer。
3. 反之，从 FastThreadLocal 中返回一个可重用的直接内存 Buffer，后面和上面的操作一样，写入，删除旧的，返回新的。注意，这里返回的可重用的 Buffer，当调用他的 release 方法的时候，实际上是归还到了 FastThreadLocal 中。对象池的最佳实践。

关于 addMessage 方法，我们将在另一篇文章Netty 出站缓冲区 ChannelOutboundBuffer 源码解析（isWritable 属性的重要性）详细阐述，这里只需要知道，他放入了一个 出站缓存中就行了。

3. unSafe 的 flush 方法

重点是 outboundBuffer.addFlush() 方法和 flush0 方法。

这两个方法在 Netty 出站缓冲区 ChannelOutboundBuffer 源码解析（isWritable 属性的重要性）

这里只需要知道，addFlush 方法将刚刚添加进出站 buffer 的数据进行检查，并准备写入 Socket。
flush0 做真正的写入操作，其中，调用了 JDK 的 Socket 的 write 方法，将 ByteBuf 封装的 ByteBuffer 写到 Socket 中。

总结

可以看到，数据真正的写出还是调用了 head 的节点中 unsafe 的 write 方法和 flush 方法，其中，write 只是将数据写入到了出站缓冲区，并且，write 方法可以调用多次，flush 才是真正的写入到 Socket。而更详细的细节，可以查看我的另一篇文章Netty 出站缓冲区 ChannelOutboundBuffer 源码解析（isWritable 属性的重要性）。

good luck ！！！！