netty-read

NioEventLoop是ServerSocketChannel和SocketChannel通用的EventLoop，从NioEventLoop的执行逻辑开始

protected void run() {
  for (;;) {
    switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
      case SelectStrategy.CONTINUE:
        continue;
      case SelectStrategy.SELECT:
        select(wakenUp.getAndSet(false));
        if (wakenUp.get()) {
          selector.wakeup();
        }
      default:
        // fallthrough
    }

    cancelledKeys = 0;
    needsToSelectAgain = false;
    final int ioRatio = this.ioRatio;
    if (ioRatio == 100) {
      try {
        //处理IO事件
        processSelectedKeys();
      } finally {
        // Ensure we always run tasks.
        //处理队列中任务
        runAllTasks();
      }
    } else {
      final long ioStartTime = System.nanoTime();
      try {
        processSelectedKeys();
      } finally {
        // Ensure we always run tasks.
        final long ioTime = System.nanoTime() - ioStartTime;
        runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
      }
    }
  }
}

//eventLoop持有selector，可以得到selectedKeys
private void processSelectedKeysPlain(Set<SelectionKey> selectedKeys) {

  if (selectedKeys.isEmpty()) {
    return;
  }

  Iterator<SelectionKey> i = selectedKeys.iterator();
  for (;;) {
    final SelectionKey k = i.next();
    //java.nio.channels.ServerSocketChannel的attachment是io.netty.channel.socket.ServerSocketChannel，
    //java.nio.channels.SocketChannel的attachment是io.netty.channel.socket.SocketChannel，
    final Object a = k.attachment();
    i.remove();

    if (a instanceof AbstractNioChannel) {
      processSelectedKey(k, (AbstractNioChannel) a);
    } else {
      @SuppressWarnings("unchecked")
      NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;
      processSelectedKey(k, task);
    }

    if (!i.hasNext()) {
      break;
    }

    if (needsToSelectAgain) {
      selectAgain();
      selectedKeys = selector.selectedKeys();

      // Create the iterator again to avoid ConcurrentModificationException
      if (selectedKeys.isEmpty()) {
        break;
      } else {
        i = selectedKeys.iterator();
      }
    }
  }
}

//涵盖了SelectionKey.OP_CONNECT、SelectionKey.OP_WRITE、SelectionKey.OP_READ、SelectionKey.OP_ACCEPT四种事件
private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
  final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();

  int readyOps = k.readyOps();

  if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
    int ops = k.interestOps();
    ops &= ~SelectionKey.OP_CONNECT;
    k.interestOps(ops);

    unsafe.finishConnect();
  }

  if ((readyOps & SelectionKey.OP_WRITE) != 0) {
    ch.unsafe().forceFlush();
  }
  if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
      //重点关注    
    unsafe.read();
  }
}

下面分别对NioMessageUnsafe以及NioByteUnsafe的read操作进行分析

NioMessageUnsafe用于ServerSocketChannel，读取的是SocketChannel对象

private final class NioMessageUnsafe extends AbstractNioUnsafe {
    //......
    
    public void read() {
      assert eventLoop().inEventLoop();
      final ChannelConfig config = config();
      final ChannelPipeline pipeline = pipeline();
      final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();
      allocHandle.reset(config);

      boolean closed = false;
      Throwable exception = null;

      try {
        do {
            //真正的读取操作
          int localRead = doReadMessages(readBuf);
          //读完了
          if (localRead == 0) {
            break;
          }
          //localRead<0说明对端关闭了
          if (localRead < 0) {
            closed = true;
            break;
          }

          allocHandle.incMessagesRead(localRead);
        } while (allocHandle.continueReading());
      } catch (Throwable t) {
        exception = t;
      }

      int size = readBuf.size();
      for (int i = 0; i < size; i ++) {
        readPending = false;
        //发送给Handler处理，即回调Handler的channelRead。
        //对于serverSocketChannel来说，readBuf中装的是SocketChannel，
        //fireChannelRead就是发送给ServerBootstrapAcceptor，由ServerBootstrapAcceptor注册SocketChannel
        pipeline.fireChannelRead(readBuf.get(i));
      }
      readBuf.clear();
      allocHandle.readComplete();
      //回调Handler的channelReadComplete
      pipeline.fireChannelReadComplete();

      if (exception != null) {
        closed = closeOnReadError(exception);
            //回调Handler的ExceptionCaught
        pipeline.fireExceptionCaught(exception);
      }

      if (closed) {
        inputShutdown = true;
        if (isOpen()) {
            close(voidPromise());
        }
      }
    }
    
    //......
}

protected int doReadMessages(List<Object> buf) throws Exception {
    //调用java.nio.channels.ServerSocketChannel.accept()
  SocketChannel ch = SocketUtils.accept(javaChannel());

  try {
    if (ch != null) {
      buf.add(new NioSocketChannel(this, ch));
      return 1;
    }
  } catch (Throwable t) {
    try {
      ch.close();
    } catch (Throwable t2) {
      logger.warn("Failed to close a socket.", t2);
    }
  }
  return 0;
}

NioByteUnsafe用于SocketChannel，读取的是字节序列

protected class NioByteUnsafe extends AbstractNioUnsafe {
    //......
    public final void read() {
      final ChannelConfig config = config();
      final ChannelPipeline pipeline = pipeline();
      final ByteBufAllocator allocator = config.getAllocator();
      final RecvByteBufAllocator.Handle allocHandle = recvBufAllocHandle();
      allocHandle.reset(config);

      ByteBuf byteBuf = null;
      boolean close = false;
      try {
        do {
            //每次读取都重新分配Buffer
          byteBuf = allocHandle.allocate(allocator);
          //真正的读取操作
          allocHandle.lastBytesRead(doReadBytes(byteBuf));
          //读到0表示数据读完，-1表示对端已关闭
          if (allocHandle.lastBytesRead() <= 0) {
            // nothing was read. release the buffer.
            byteBuf.release();
            byteBuf = null;
            //读到-1，表示对端已关闭
            close = allocHandle.lastBytesRead() < 0;
            break;
          }

          allocHandle.incMessagesRead(1);
          readPending = false;
          //将读取到的数据发送给Handler，即回调Handler的ChannelRead
          pipeline.fireChannelRead(byteBuf);
          byteBuf = null;
        } while (allocHandle.continueReading());
            
        allocHandle.readComplete();
        //回调Handler的ChannelReadComplete
        pipeline.fireChannelReadComplete();

        if (close) {
          closeOnRead(pipeline);
        }
      } catch (Throwable t) {
        handleReadException(pipeline, byteBuf, t, close, allocHandle);//会调用pipeline.fireChannelReadComplete和pipeline.fireExceptionCaught
      }
    }
    //......
}

protected int doReadBytes(ByteBuf byteBuf) throws Exception {
  final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();
  allocHandle.attemptedBytesRead(byteBuf.writableBytes());
  //从java.nio.channels.SocketChannel中读取allocHandle.attemptedBytesRead()个字节置byteBuf中
  return byteBuf.writeBytes(javaChannel(), allocHandle.attemptedBytesRead());
}