netty ServerBootStrap解析： http://donald-draper.iteye.com/blog/2392572
netty Bootstrap解析： http://donald-draper.iteye.com/blog/2392593
netty 通道接口定义: http://donald-draper.iteye.com/blog/2392740
netty 抽象通道初始化： http://donald-draper.iteye.com/blog/2392801
netty 抽象Unsafe定义： http://donald-draper.iteye.com/blog/2393053
netty 通道Outbound缓冲区： http://donald-draper.iteye.com/blog/2393098
netty 抽象通道后续： http://donald-draper.iteye.com/blog/2393166
netty 抽象nio通道： http://donald-draper.iteye.com/blog/2393269
netty 抽象nio字节通道： http://donald-draper.iteye.com/blog/2393323
netty 抽象nio消息通道： http://donald-draper.iteye.com/blog/2393364
netty NioServerSocketChannel解析： http://donald-draper.iteye.com/blog/2393443
netty 通道配置接口定义： http://donald-draper.iteye.com/blog/2393484
netty 默认通道配置初始化： http://donald-draper.iteye.com/blog/2393504
netty 默认通道配置后续： http://donald-draper.iteye.com/blog/2393510
netty 字节buf定义： http://donald-draper.iteye.com/blog/2393813
netty 资源泄漏探测器： http://donald-draper.iteye.com/blog/2393940
netty 抽象字节buf解析： http://donald-draper.iteye.com/blog/2394078
netty 抽象字节buf引用计数器： http://donald-draper.iteye.com/blog/2394109
netty 复合buf概念： http://donald-draper.iteye.com/blog/2394408
netty 抽象字节buf分配器： http://donald-draper.iteye.com/blog/2394419
netty Unpooled字节buf分配器： http://donald-draper.iteye.com/blog/2394619
netty Pooled字节buf分配器： http://donald-draper.iteye.com/blog/2394814
引言：
上一篇文章我们看了Pooled字节buf分配器，先来回顾一下：
Pooled字节buf分配器，内部有一个堆buf和direct buf分配Region区（PoolArena），每个Region的内存块（PoolChunk）size为chunkSize，每个内存块内存页（PoolSubpage）大小，默认为8k。Pooled 堆buf是基于字节数组，而direct buf是基于nio 字节buf。Pooled字节分配器分配heap和direct buf时，首先获取线程本地buf缓存PoolThreadCache，从buf获取对应的heap或direct分配区，分配区创建buf（PooledByteBuf），然后将buf放到内存块中管理，根据buf的容量，将放到相应tiny，small，normal Memory Region Cache（MemoryRegionCache）中。每个Pooled buf通过内存的Recycler，重用buf。Pool字节buf内部有一个回收器Recycler，管理字节buf，而回收器内部是将对象放在一个线程本地栈中管理。
从看了ServerSocket通道之后，我们把字节buf（heap，direct），及字节buf分配器（Unpooled，Pooled）,
今天我们回到Socket通道，由于socket通道我们讲了好久，先来把Nio socket通道的父类抽象字节通道回顾一下：
写通道Outbound缓冲区，即遍历刷新链上的写请求，如果写请求消息为字节buf，则调用doWriteBytes完成实际数据发送操作，待子类扩展，如果写请求消息为文件Region，调用doWriteFileRegion完成实际数据发送操作，待子类扩展，数据发送，则更新通道的数据发送进度，并从刷新链上移除写请求；如果所有写请求发送完毕，则重新添加写操作事件到选择key兴趣事件集，否则继续刷新通道Outbound缓冲区中的写请求。
nio字节Unsafe读操作，从通道接收缓冲区读取数据，通知通道处理读取数据,触发Channel管道线的fireChannelRead事件，待数据读取完毕，触发Channel管道线的fireChannelReadComplete事件，如果在读数据的过程中，通道关闭，则触发通道输入关闭事件（fireUserEventTriggered），如果在读数据的过程中，发生异常，则读取缓存区中没有读完的数据，并通道通道处理剩余数据。
现在来看socket通道：
/**
* {@link io.netty.channel.socket.SocketChannel} which uses NIO selector based implementation.
*/
public class NioSocketChannel extends AbstractNioByteChannel implements io.netty.channel.socket.SocketChannel {
private static final InternalLogger logger = InternalLoggerFactory.getInstance(NioSocketChannel.class);
//选择器提供者
private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();
private final SocketChannelConfig config;//socket通道配置
/**
* Create a new instance
*/
public NioSocketChannel() {
this(DEFAULT_SELECTOR_PROVIDER);
}
/**
* Create a new instance using the given {@link SelectorProvider}.
*/
public NioSocketChannel(SelectorProvider provider) {
this(newSocket(provider));
}
/**
* Create a new instance using the given {@link SocketChannel}.
*/
public NioSocketChannel(SocketChannel socket) {
this(null, socket);
}
/**
* Create a new instance
*
* @param parent the {@link Channel} which created this instance or {@code null} if it was created by the user
* @param socket the {@link SocketChannel} which will be used
*/
public NioSocketChannel(Channel parent, SocketChannel socket) {
super(parent, socket);
config = new NioSocketChannelConfig(this, socket.socket());
}
}
来看创建socket通道：
private static SocketChannel newSocket(SelectorProvider provider) {
try {
/**
* Use the {@link SelectorProvider} to open {@link SocketChannel} and so remove condition in
* {@link SelectorProvider#provider()} which is called by each SocketChannel.open() otherwise.
*委托给选择提供者，打开一个socket通道
* See [url=https://github.com/netty/netty/issues/2308]#2308[/url].
*/
return provider.openSocketChannel();
} catch (IOException e) {
throw new ChannelException("Failed to open a socket.", e);
}
}
socket通道配置：
private final class NioSocketChannelConfig extends DefaultSocketChannelConfig {
private NioSocketChannelConfig(NioSocketChannel channel, Socket javaSocket) {
super(channel, javaSocket);
}
@Override
protected void autoReadCleared() {
clearReadPending();
}
}
从上面可以看出，socket通道初始化，主要是创建socket通道，初始化socket通道配置NioSocketChannelConfig。
来看绑定地址：
@Override
protected void doBind(SocketAddress localAddress) throws Exception {
doBind0(localAddress);
}
private void doBind0(SocketAddress localAddress) throws Exception {
if (PlatformDependent.javaVersion() >= 7) {
//jdk >= 1.7 则使用socket通道绑定地址
SocketUtils.bind(javaChannel(), localAddress);
} else {
//否则委托通道内关联的socket
SocketUtils.bind(javaChannel().socket(), localAddress);
}
}
//SocketUtils
public static void bind(final SocketChannel socketChannel, final SocketAddress address) throws IOException {
try {
//在当前访问控制权限下，委托给socket通道绑定socket地址
AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
@Override
public Void run() throws IOException {
socketChannel.bind(address);
return null;
}
});
} catch (PrivilegedActionException e) {
throw (IOException) e.getCause();
}
}
public static void bind(final Socket socket, final SocketAddress bindpoint) throws IOException {
try {
AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
@Override
public Void run() throws IOException {
socket.bind(bindpoint);
return null;
}
});
} catch (PrivilegedActionException e) {
throw (IOException) e.getCause();
}
}
从上面来看地址绑定，如果jdk >= 1.7 则使用socket通道绑定地址，否则委托通道内关联的socket。
再来看连接操作：
@Override
protected boolean doConnect(SocketAddress remoteAddress, SocketAddress localAddress) throws Exception {
if (localAddress != null) {
//本地地址不为空，则绑定本地socket地址
doBind0(localAddress);
}
boolean success = false;
try {
//否则委托SocketUtils
boolean connected = SocketUtils.connect(javaChannel(), remoteAddress);
if (!connected) {
//如果连接操作没完成，则添加连接事件到选择key兴趣事件集
selectionKey().interestOps(SelectionKey.OP_CONNECT);
}
success = true;
return connected;
} finally {
if (!success) {
doClose();
}
}
}
//SocketUtils
public static boolean connect(final SocketChannel socketChannel, final SocketAddress remoteAddress)
throws IOException {
try {
return AccessController.doPrivileged(new PrivilegedExceptionAction<Boolean>() {
@Override
public Boolean run() throws IOException {
//直接委托给socket通道
return socketChannel.connect(remoteAddress);
}
});
} catch (PrivilegedActionException e) {
throw (IOException) e.getCause();
}
}
//完成连接：
@Override
protected void doFinishConnect() throws Exception {
//直接调用内部socket通道的完成连接方法
if (!javaChannel().finishConnect()) {
throw new Error();
}
}
再来看读数据到字节buf
@Override
protected int doReadBytes(ByteBuf byteBuf) throws Exception {
//从unsafe获取字节buf分配器Handle
final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();
//设置需要尝试读字节数
allocHandle.attemptedBytesRead(byteBuf.writableBytes());
//委托给字节buf，从Socket通道读取数据，写到当前buf
return byteBuf.writeBytes(javaChannel(), allocHandle.attemptedBytesRead());
}
由于在netty中有Pooled、Unpooled两种字节buf，每种又有heap和direct两种实际buf，我们以
UnpooledHeapByteBuf为例：
//AbstractByteBuf
@Override
public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
ensureAccessible();
ensureWritable(length);
int writtenBytes = setBytes(writerIndex, in, length);
if (writtenBytes > 0) {
writerIndex += writtenBytes;
}
return writtenBytes;
}
//UnpooledHeapByteBuf
@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
ensureAccessible();
try {
return in.read((ByteBuffer) internalNioBuffer().clear().position(index).limit(index + length));
} catch (ClosedChannelException ignored) {
return -1;
}
}
从上面可以看出，socket通道读取操作，实际委托给socket通道的read操作，从Socket通道读取数据，写到当前buf。
再来看写操作：
先来看写字节buf
@Override
protected int doWriteBytes(ByteBuf buf) throws Exception {
final int expectedWrittenBytes = buf.readableBytes();
//从当前buf读取数据，写socket通道中
return buf.readBytes(javaChannel(), expectedWrittenBytes);
}
从上面可以看出
//UnpooledHeapByteBuf
@Override
public int readBytes(GatheringByteChannel out, int length) throws IOException {
checkReadableBytes(length);
int readBytes = getBytes(readerIndex, out, length, true);
readerIndex += readBytes;
return readBytes;
}
private int getBytes(int index, GatheringByteChannel out, int length, boolean internal) throws IOException {
ensureAccessible();
ByteBuffer tmpBuf;
if (internal) {
tmpBuf = internalNioBuffer();
} else {
tmpBuf = ByteBuffer.wrap(array);
}
return out.write((ByteBuffer) tmpBuf.clear().position(index).limit(index + length));
}
从上面可以看出写字节buf，实际委托给socket通道的写操作，从当前buf读取数据，写socket通道中。
再来看写文件Region
@Override
protected long doWriteFileRegion(FileRegion region) throws Exception {
final long position = region.transferred();
return region.transferTo(javaChannel(), position);
}
//DefaultFileRegion
public class DefaultFileRegion extends AbstractReferenceCounted implements FileRegion {
private static final InternalLogger logger = InternalLoggerFactory.getInstance(DefaultFileRegion.class);
private final File f;//关联文件
private final long position;
private final long count;
private long transferred;
private FileChannel file;//关联文件通道
/**
* Explicitly open the underlying file-descriptor if not done yet.
打开一个文件通道
*/
public void open() throws IOException {
if (!isOpen() && refCnt() > 0) {
// Only open if this DefaultFileRegion was not released yet.
file = new RandomAccessFile(f, "r").getChannel();
}
}
//转移文件region的内容到可写字节通道
@Override
public long transferTo(WritableByteChannel target, long position) throws IOException {
long count = this.count - position;
if (count < 0 || position < 0) {
throw new IllegalArgumentException(
"position out of range: " + position +
" (expected: 0 - " + (this.count - 1) + ')');
}
if (count == 0) {
return 0L;
}
if (refCnt() == 0) {
throw new IllegalReferenceCountException(0);
}
// Call open to make sure fc is initialized. This is a no-oop if we called it before.
//确保通道打开
open();
//从文件Region读取数据，写到通道中
long written = file.transferTo(this.position + position, count, target);
if (written > 0) {
transferred += written;
}
return written;
}
...
}
从上面可以看，socket通道写文件region，委托给文件Region的转移数据操作transferTo，
从文件Region读取数据，写到通道中。
如果前面的文章忘记可以看一下这篇文章：
netty 通道Outbound缓冲区： http://donald-draper.iteye.com/blog/2393098
再看写通道Outbound缓冲区：
@Override
protected void doWrite(ChannelOutboundBuffer in) throws Exception {
for (;;) {
int size = in.size();//获取刷新写请求size
if (size == 0) {
// All written so clear OP_WRITE
//如果所有写请求都已经刷新，则清除选择key兴趣事件集，移除写事件
clearOpWrite();
break;
}
long writtenBytes = 0;
boolean done = false;
boolean setOpWrite = false;
// Ensure the pending writes are made of ByteBufs only.
//获取Outbound缓冲中的刷新队列写请求对应的nio字节buf
ByteBuffer[] nioBuffers = in.nioBuffers();
int nioBufferCnt = in.nioBufferCount();//nio字节buf数量
long expectedWrittenBytes = in.nioBufferSize();//需要些的字节数
SocketChannel ch = javaChannel();//获取关联通道
// Always us nioBuffers() to workaround data-corruption.
// See https://github.com/netty/netty/issues/2761
switch (nioBufferCnt) {
case 0:
// We have something else beside ByteBuffers to write so fallback to normal writes.
super.doWrite(in);
return;
case 1:
// Only one ByteBuf so use non-gathering write
ByteBuffer nioBuffer = nioBuffers[0];
for (int i = config().getWriteSpinCount() - 1; i >= 0; i --) {
//委托给内部通道的写操作
final int localWrittenBytes = ch.write(nioBuffer);
if (localWrittenBytes == 0) {
setOpWrite = true;
break;
}
expectedWrittenBytes -= localWrittenBytes;
writtenBytes += localWrittenBytes;
if (expectedWrittenBytes == 0) {
done = true;
break;
}
}
break;
default:
for (int i = config().getWriteSpinCount() - 1; i >= 0; i --) {
//委托给内部通道的写操作
final long localWrittenBytes = ch.write(nioBuffers, 0, nioBufferCnt);
if (localWrittenBytes == 0) {
setOpWrite = true;
break;
}
expectedWrittenBytes -= localWrittenBytes;
writtenBytes += localWrittenBytes;
if (expectedWrittenBytes == 0) {
done = true;
break;
}
}
break;
}
// Release the fully written buffers, and update the indexes of the partially written buffer.
//根据已写字节数，从Outbound刷新队列中，移除已经刷新成功的写请求
in.removeBytes(writtenBytes);
if (!done) {
// Did not write all buffers completely.
incompleteWrite(setOpWrite);
break;
}
}
}
上面与ChannelOutboundBuffer相关的文章，见上面的连接，这里不再重复，附篇中也有。
从上面可以看出，写通道Outbound缓存区，首先从Outbound缓存区获取刷新链上的写请求对应的
字节buf，然后委托给socket通道的写操作，发送数据，发送成功后，从刷新链上移除已经发送的写请求。
再来看关闭socket通道输入流：
@Override
public ChannelFuture shutdownInput() {
return shutdownInput(newPromise());
}
@Override
public ChannelFuture shutdownInput(final ChannelPromise promise) {
//从事件循环反注册
Executor closeExecutor = ((NioSocketChannelUnsafe) unsafe()).prepareToClose();
if (closeExecutor != null) {//如果关闭执行器不为空
closeExecutor.execute(new Runnable() {
@Override
public void run() {
//执行实际关闭输入流工作
shutdownInput0(promise);
}
});
} else {
//在当前事件循环中在，则直接执行，否则创建一个线程，完成实际关闭输入流工作
EventLoop loop = eventLoop();
if (loop.inEventLoop()) {
shutdownInput0(promise);
} else {
loop.execute(new Runnable() {
@Override
public void run() {
shutdownInput0(promise);
}
});
}
}
return promise;
}
来看从事件循环反注册
//创建Unsafe
@Override
protected AbstractNioUnsafe newUnsafe() {
return new NioSocketChannelUnsafe();
}
//NioSocketChannelUnsafe
private final class NioSocketChannelUnsafe extends NioByteUnsafe {
@Override
protected Executor prepareToClose() {
try {
if (javaChannel().isOpen() && config().getSoLinger() > 0) {
// We need to cancel this key of the channel so we may not end up in a eventloop spin
// because we try to read or write until the actual close happens which may be later due
// SO_LINGER handling.
// See https://github.com/netty/netty/issues/4449
//从事件循环反注册
doDeregister();
return GlobalEventExecutor.INSTANCE;
}
} catch (Throwable ignore) {
// Ignore the error as the underlying channel may be closed in the meantime and so
// getSoLinger() may produce an exception. In this case we just return null.
// See https://github.com/netty/netty/issues/4449
}
return null;
}
}
//AbstractNioChannel
@Override
protected void doDeregister() throws Exception {
//事件循环，取消选择key
eventLoop().cancel(selectionKey());
}
再来看实际关闭输入流：
private void shutdownInput0(final ChannelPromise promise) {
try {
shutdownInput0();
promise.setSuccess();
} catch (Throwable t) {
promise.setFailure(t);
}
}
private void shutdownInput0() throws Exception {
if (PlatformDependent.javaVersion() >= 7) {
//委托给socket通道
javaChannel().shutdownInput();
} else {//否则，委托给通道关联的socket
javaChannel().socket().shutdownInput();
}
}
从上面可以看出，关闭数据流，就是从事件循环反注册，即事件循环取消选择key，
然后如果jdk大于1.7 则委托socket通道关闭输入流，否则委托通道内关联的socket。
再来看关闭输出流，与关闭输入流思路一致，就不多说了：
@Override
public ChannelFuture shutdownOutput() {
return shutdownOutput(newPromise());
}
@Override
public ChannelFuture shutdownOutput(final ChannelPromise promise) {
Executor closeExecutor = ((NioSocketChannelUnsafe) unsafe()).prepareToClose();
if (closeExecutor != null) {
closeExecutor.execute(new Runnable() {
@Override
public void run() {
shutdownOutput0(promise);
}
});
} else {
EventLoop loop = eventLoop();
if (loop.inEventLoop()) {
shutdownOutput0(promise);
} else {
loop.execute(new Runnable() {
@Override
public void run() {
shutdownOutput0(promise);
}
});
}
}
return promise;
}
private void shutdownOutput0(final ChannelPromise promise) {
try {
shutdownOutput0();
promise.setSuccess();
} catch (Throwable t) {
promise.setFailure(t);
}
}
private void shutdownOutput0() throws Exception {
if (PlatformDependent.javaVersion() >= 7) {
javaChannel().shutdownOutput();
} else {
javaChannel().socket().shutdownOutput();
}
}
再来看关闭通道，
@Override
public ChannelFuture shutdown() {
return shutdown(newPromise());
}
@Override
public ChannelFuture shutdown(final ChannelPromise promise) {
Executor closeExecutor = ((NioSocketChannelUnsafe) unsafe()).prepareToClose();
if (closeExecutor != null) {
closeExecutor.execute(new Runnable() {
@Override
public void run() {
shutdown0(promise);
}
});
} else {
EventLoop loop = eventLoop();
if (loop.inEventLoop()) {
shutdown0(promise);
} else {
loop.execute(new Runnable() {
@Override
public void run() {
shutdown0(promise);
}
});
}
}
return promise;
}
private void shutdown0(final ChannelPromise promise) {
Throwable cause = null;
try {
shutdownOutput0();
} catch (Throwable t) {
cause = t;
}
try {
shutdownInput0();
} catch (Throwable t) {
if (cause == null) {
promise.setFailure(t);
} else {
logger.debug("Exception suppressed because a previous exception occurred.", t);
promise.setFailure(cause);
}
return;
}
if (cause == null) {
promise.setSuccess();
} else {
promise.setFailure(cause);
}
}
从上面可以看出关闭通道实际为关闭通道输入流和输出流。
再来开断开连接:
@Override
protected void doDisconnect() throws Exception {
doClose();
}
@Override
protected void doClose() throws Exception {
super.doClose();
javaChannel().close();
}
从上面可以看出，断开连接实际为close通道。
再来看其他方法，下面这些方法，瞄一眼就行，没有太多要说的：
@Override
public ServerSocketChannel parent() {
return (ServerSocketChannel) super.parent();
}
@Override
public SocketChannelConfig config() {
return config;
}
@Override
protected SocketChannel javaChannel() {
return (SocketChannel) super.javaChannel();
}
@Override
public boolean isActive() {
SocketChannel ch = javaChannel();
return ch.isOpen() && ch.isConnected();
}
@Override
public boolean isOutputShutdown() {
return javaChannel().socket().isOutputShutdown() || !isActive();
}
@Override
public boolean isInputShutdown() {
return javaChannel().socket().isInputShutdown() || !isActive();
}
@Override
public boolean isShutdown() {
Socket socket = javaChannel().socket();
return socket.isInputShutdown() && socket.isOutputShutdown() || !isActive();
}
@Override
public InetSocketAddress localAddress() {
return (InetSocketAddress) super.localAddress();
}
@Override
public InetSocketAddress remoteAddress() {
return (InetSocketAddress) super.remoteAddress();
}
总结：
nio socket通道初始化，主要是创建socket通道，初始化socket通道配置NioSocketChannelConfig。地址绑定操作，如果jdk大于1.7 则socket通道直接绑定地址，否则委托通道内关联的socket。连接操作，直接委托给内部的socket通道连接操作。socket通道读取操作，实际委托给socket通道的read操作，从Socket通道读取数据，写到当前buf。写字节buf，实际委托给socket通道的写操作，从当前buf读取数据，写socket通道中。socket通道写文件region，委托给文件Region的转移数据操作transferTo，从文件Region读取数据，写到通道中。
写通道Outbound缓存区，首先从Outbound缓存区获取刷新链上的写请求对应的字节buf，然后委托给socket通道的写操作，发送数据，发送成功后，从刷新链上移除已经发送的写请求。关闭数据流，就是从事件循环反注册，即事件循环取消选择key，然后如果jdk大于1.7 则委托socket通道关闭输入流，否则委托通道内关联的socket。关闭输出流与关闭输入流思路一致。关闭通道实际为关闭通道输入流和输出流。断开连接实际为close通道。
附：
//ChannelOutboundBuffer
public final class ChannelOutboundBuffer {
// Assuming a 64-bit JVM:
// - 16 bytes object header
// - 8 reference fields
// - 2 long fields
// - 2 int fields
// - 1 boolean field
// - padding
//Entry buf 头部数据size
static final int CHANNEL_OUTBOUND_BUFFER_ENTRY_OVERHEAD =
SystemPropertyUtil.getInt("io.netty.transport.outboundBufferEntrySizeOverhead", 96);
private static final InternalLogger logger = InternalLoggerFactory.getInstance(ChannelOutboundBuffer.class);
//通道Outbound buf 线程本地Buf，存放刷新链表中的写请求消息
private static final FastThreadLocal<ByteBuffer[]> NIO_BUFFERS = new FastThreadLocal<ByteBuffer[]>() {
@Override
protected ByteBuffer[] initialValue() throws Exception {
return new ByteBuffer[1024];
}
};
//buf 关联通道
private final Channel channel;
// Entry(flushedEntry) --> ... Entry(unflushedEntry) --> ... Entry(tailEntry)
//
// The Entry that is the first in the linked-list structure that was flushed
private Entry flushedEntry;刷新写请求链的链头
// The Entry which is the first unflushed in the linked-list structure
private Entry unflushedEntry;//未刷新的写请求链的链头
// The Entry which represents the tail of the buffer
private Entry tailEntry;
// The number of flushed entries that are not written yet
private int flushed;//刷新Entry链上待发送的写请求数
private int nioBufferCount;//当前待发送的消息buf数量
private long nioBufferSize;//当前待发送的所有消息buf的字节数
private boolean inFail;//是否刷新失败
//通道待发送的字节数
private static final AtomicLongFieldUpdater<ChannelOutboundBuffer> TOTAL_PENDING_SIZE_UPDATER =
AtomicLongFieldUpdater.newUpdater(ChannelOutboundBuffer.class, "totalPendingSize");
@SuppressWarnings("UnusedDeclaration")
private volatile long totalPendingSize;
private static final AtomicIntegerFieldUpdater<ChannelOutboundBuffer> UNWRITABLE_UPDATER =
AtomicIntegerFieldUpdater.newUpdater(ChannelOutboundBuffer.class, "unwritable");
@SuppressWarnings("UnusedDeclaration")
private volatile int unwritable;//通道写状态
//触发通道ChannelWritabilityChanged事件任务线程
private volatile Runnable fireChannelWritabilityChangedTask;
ChannelOutboundBuffer(AbstractChannel channel) {
this.channel = channel;
}
}
再来看将刷新链上的写请求消息，添加到nio buffer数组中:
/**
* Returns an array of direct NIO buffers if the currently pending messages are made of {@link ByteBuf} only.
* {@link #nioBufferCount()} and {@link #nioBufferSize()} will return the number of NIO buffers in the returned
* array and the total number of readable bytes of the NIO buffers respectively.
将刷新链中的写请求对象消息放到nio buf数组中。#nioBufferCount和#nioBufferSize，将返回当前nio buf数组的长度
和可读字节数
*
* Note that the returned array is reused and thus should not escape
* {@link AbstractChannel#doWrite(ChannelOutboundBuffer)}.
* Refer to {@link NioSocketChannel#doWrite(ChannelOutboundBuffer)} for an example.
返回的nio buf将会被 NioSocketChannel#doWrite方法重用
*
*/
public ByteBuffer[] nioBuffers() {
long nioBufferSize = 0;//nio buf数组中的字节数
int nioBufferCount = 0;//nio buf数组长度
final InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
//获取通道Outbound缓存区线程本地的niobuf数组
ByteBuffer[] nioBuffers = NIO_BUFFERS.get(threadLocalMap);
Entry entry = flushedEntry;
//遍历刷新链，链上的写请求Entry的消息必须为ByteBuf
while (isFlushedEntry(entry) && entry.msg instanceof ByteBuf) {
if (!entry.cancelled) {
//在写请求没有取消的情况下，获取写请求消息buf，及buf的读索引，和可读字节数
ByteBuf buf = (ByteBuf) entry.msg;
final int readerIndex = buf.readerIndex();
final int readableBytes = buf.writerIndex() - readerIndex;
if (readableBytes > 0) {
if (Integer.MAX_VALUE - readableBytes < nioBufferSize) {
//如果消息buf可读字节数+nioBufferSize大于整数的最大值，则跳出循环
// If the nioBufferSize + readableBytes will overflow an Integer we stop populate the
// ByteBuffer array. This is done as bsd/osx don't allow to write more bytes then
// Integer.MAX_VALUE with one writev(...) call and so will return 'EINVAL', which will
// raise an IOException. On Linux it may work depending on the
// architecture and kernel but to be safe we also enforce the limit here.
// This said writing more the Integer.MAX_VALUE is not a good idea anyway.
//
// See also:
// - https://www.freebsd.org/cgi/man.cgi?query=write&sektion=2
// - http://linux.die.net/man/2/writev
break;
}
//更新buf的size
nioBufferSize += readableBytes;
int count = entry.count;
if (count == -1) {
//noinspection ConstantValueVariableUse
entry.count = count = buf.nioBufferCount();
}
//需要buf的数量
int neededSpace = nioBufferCount + count;
//如果buf需求数量大于当前nio buf数组
if (neededSpace > nioBuffers.length) {
//则扩容nio数组为原来的两倍，
nioBuffers = expandNioBufferArray(nioBuffers, neededSpace, nioBufferCount);
//更新nio buf数组
NIO_BUFFERS.set(threadLocalMap, nioBuffers);
}
if (count == 1) {
//如果需要的buf数量为1，则获取写请求的buf
ByteBuffer nioBuf = entry.buf;
if (nioBuf == null) {
// cache ByteBuffer as it may need to create a new ByteBuffer instance if its a
// derived buffer
//如果buf为空，则创建一个buf实例
entry.buf = nioBuf = buf.internalNioBuffer(readerIndex, readableBytes);
}
//将消息buf，添加到nio buf数组中
nioBuffers[nioBufferCount ++] = nioBuf;
} else {
//否则获取写请求的buf数组
ByteBuffer[] nioBufs = entry.bufs;
if (nioBufs == null) {
// cached ByteBuffers as they may be expensive to create in terms
// of Object allocation
//分配buf数组
entry.bufs = nioBufs = buf.nioBuffers();
}
//添加写请求buf数组到通道Outbound缓存区的nio buf数组中
nioBufferCount = fillBufferArray(nioBufs, nioBuffers, nioBufferCount);
}
}
}
entry = entry.next;
}
//更新当前nio buffer 计数器和字节数
this.nioBufferCount = nioBufferCount;
this.nioBufferSize = nioBufferSize;
return nioBuffers;
}
1.
//则扩容nio数组
private static ByteBuffer[] expandNioBufferArray(ByteBuffer[] array, int neededSpace, int size) {
int newCapacity = array.length;
do {
// double capacity until it is big enough
// See https://github.com/netty/netty/issues/1890
//则扩容nio数组为原来的两倍
newCapacity <<= 1;
if (newCapacity < 0) {
throw new IllegalStateException();
}
} while (neededSpace > newCapacity);
ByteBuffer[] newArray = new ByteBuffer[newCapacity];
//拷贝原始中size buf到新的的buf数组中
System.arraycopy(array, 0, newArray, 0, size);
return newArray;
}
2.
//添加写请求buf数组到通道Outbound缓存区的nio buf数组中
private static int fillBufferArray(ByteBuffer[] nioBufs, ByteBuffer[] nioBuffers, int nioBufferCount) {
//遍历添加的buf数组，添加到缓存区的nio buf数组中
for (ByteBuffer nioBuf: nioBufs) {
if (nioBuf == null) {
break;
}
nioBuffers[nioBufferCount ++] = nioBuf;
}
return nioBufferCount;
}
从上面可以看出：将刷新链上的写请求消息，添加到nio buffer数组中方法nioBuffers，
主要是将刷新链上的写请求消息包装成direct buf添加到通道Outbound缓存区的nio buf数组中，
这个方法主要在NioSocketChannel#doWrite方法重用。方法调用后，#nioBufferCount和#nioBufferSize，将返回当前nio buf数组的长度和可读字节数。
再来看移除移动字节数据
/**
* Removes the fully written entries and update the reader index of the partially written entry.
* This operation assumes all messages in this buffer is {@link ByteBuf}.
从刷新写请求链表，移除writtenBytes个字节数
*/
public void removeBytes(long writtenBytes) {
for (;;) {
Object msg = current();//获取当前写请求消息
if (!(msg instanceof ByteBuf)) {
//写请求非ByteBuf实例，且writtenBytes为0
assert writtenBytes == 0;
break;
}
final ByteBuf buf = (ByteBuf) msg;
//获取消息buf的读指针
final int readerIndex = buf.readerIndex();
//获取buf中可读的字节数
final int readableBytes = buf.writerIndex() - readerIndex;
//如果可读字节数小于，需要移除的字节数
if (readableBytes <= writtenBytes) {
if (writtenBytes != 0) {
//则更新写请求任务进度
progress(readableBytes);
//更新移除字节数
writtenBytes -= readableBytes;
}
//移除链头写请求消息
remove();
} else { // readableBytes > writtenBytes
if (writtenBytes != 0) {
//如果可读字节数大于需要移除的字节数，则移动消息buf的读索引到readerIndex + (int) writtenBytes位置
buf.readerIndex(readerIndex + (int) writtenBytes);
//则更新写请求任务进度
progress(writtenBytes);
}
break;
}
}
//最后清除nio buffer
clearNioBuffers();
}
/**
* Return the current message to write or {@code null} if nothing was flushed before and so is ready to be written.
返回当前需要发送的消息
*/
public Object current() {
Entry entry = flushedEntry;
if (entry == null) {
return null;
}
return entry.msg;
}
/**
* Notify the {@link ChannelPromise} of the current message about writing progress.
获取通道刷新任务的进度
*/
public void progress(long amount) {
Entry e = flushedEntry;
assert e != null;
ChannelPromise p = e.promise;
if (p instanceof ChannelProgressivePromise) {
long progress = e.progress + amount;
e.progress = progress;
((ChannelProgressivePromise) p).tryProgress(progress, e.total);
}
}
/**
* Will remove the current message, mark its {@link ChannelPromise} as success and return {@code true}. If no
* flushed message exists at the time this method is called it will return {@code false} to signal that no more
* messages are ready to be handled.
移除当前消息，并标记通道异步任务为成功，并返回true。如果没有刷新消息存在，则返回false，表示没有消息需要处理
*/
public boolean remove() {
Entry e = flushedEntry;
if (e == null) {
//刷新消息链为空，则清除NioBuffer
clearNioBuffers();
return false;
}
Object msg = e.msg;
ChannelPromise promise = e.promise;
int size = e.pendingSize;
//移除写请求Entry
removeEntry(e);
if (!e.cancelled) {
// only release message, notify and decrement if it was not canceled before.
//写请求没有取消，则释放消息，更新任务结果，更新当前通道待发送字节数和可写状态，并触发相应的事件
ReferenceCountUtil.safeRelease(msg);
safeSuccess(promise);
decrementPendingOutboundBytes(size, false, true);
}
//取消，则回收
// recycle the entry
e.recycle();
return true;
}
移除操作有几点要看：
1.
if (e == null) {
//刷新消息链为空，则清除NioBuffer
clearNioBuffers();
return false;
}
// Clear all ByteBuffer from the array so these can be GC'ed.
// See https://github.com/netty/netty/issues/3837
private void clearNioBuffers() {
int count = nioBufferCount;
if (count > 0) {
//重置nio buf计数器，填充线程本地nio buf数组为空。
nioBufferCount = 0;
Arrays.fill(NIO_BUFFERS.get(), 0, count, null);
}
}
2.
//移除写请求Entry removeEntry(e);
private void removeEntry(Entry e) {
if (-- flushed == 0) {//刷新链为空
// processed everything
flushedEntry = null;
if (e == tailEntry) {//链尾
tailEntry = null;
unflushedEntry = null;
}
} else {
//否则，刷新链头往后移一位
flushedEntry = e.next;
}
}
从上面可以看出移除操作，主要是从刷新写请求链移除链头写请求，并则释放写请求消息，
更新写请求任务结果，当前通道待发送字节数和可写状态，并触发相应的事件。
从刷新写请求链表，移除writtenBytes个字节数方法removeBytes，自旋，直至从刷新链中移除writtenBytes个字节数，
如果链头消息的可读字节数小于writtenBytes，则移除写请求Entry，否则更新writtenBytes，
继续从刷新链中的写请求消息中移除writtenBytes个字节数。
//FileRegion
/**
* A region of a file that is sent via a {@link Channel} which supports
* [url=http://en.wikipedia.org/wiki/Zero-copy]zero-copy file transfer[/url].
*
* <h3>Upgrade your JDK / JRE</h3>
*
* {@link FileChannel#transferTo(long, long, WritableByteChannel)} has at least
* four known bugs in the old versions of Sun JDK and perhaps its derived ones.
* Please upgrade your JDK to 1.6.0_18 or later version if you are going to use
* zero-copy file transfer.
* [list]
* <li>[url=http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5103988]5103988[/url]
* - FileChannel.transferTo() should return -1 for EAGAIN instead throws IOException</li>
* <li>[url=http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6253145]6253145[/url]
* - FileChannel.transferTo() on Linux fails when going beyond 2GB boundary</li>
* <li>[url=http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6427312]6427312[/url]
* - FileChannel.transferTo() throws IOException "system call interrupted"</li>
* <li>[url=http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6524172]6470086[/url]
* - FileChannel.transferTo(2147483647, 1, channel) causes "Value too large" exception</li>
* [/list]
*
* <h3>Check your operating system and JDK / JRE</h3>
*
* If your operating system (or JDK / JRE) does not support zero-copy file
* transfer, sending a file with {@link FileRegion} might fail or yield worse
* performance. For example, sending a large file doesn't work well in Windows.
*
* <h3>Not all transports support it</h3>
*/
public interface FileRegion extends ReferenceCounted {
/**
* Returns the offset in the file where the transfer began.
*/
long position();
/**
* Returns the bytes which was transfered already.
*
* @deprecated Use {@link #transferred()} instead.
*/
@Deprecated
long transfered();
/**
* Returns the bytes which was transfered already.
*/
long transferred();
/**
* Returns the number of bytes to transfer.
*/
long count();
/**
* Transfers the content of this file region to the specified channel.
*转移当前文件Region内容到通道
* @param target the destination of the transfer
* @param position the relative offset of the file where the transfer
* begins from. For example, <tt>0</tt> will make the
* transfer start from {@link #position()}th byte and
* <tt>{@link #count()} - 1</tt> will make the last
* byte of the region transferred.
*/
long transferTo(WritableByteChannel target, long position) throws IOException;
@Override
FileRegion retain();
@Override
FileRegion retain(int increment);
@Override
FileRegion touch();
@Override
FileRegion touch(Object hint);
}