學習Netty就不得不從TCP服務器和I/O模型說起，瞭解TCP服務器架構和I/O模型的演進有助於深入瞭解Netty。

TCP服務器的架構

一般地，TCP服務器有兩種套接字，監聽套接字和已連接套接字。監聽套接字用於TCP的監聽，一旦連接建立便產生已連接套接字，服務器利用已連接套接字與客戶端進行通信。

迭代服務器
在迭代服務器中，監聽套接字會一直阻塞直到能夠接受連接，接受連接後利用已連接套接字與客戶端通信，這些工作都是在同一個線程中完成的，示意Java代碼如下。這種模式是串行處理，很難應對併發量較大的情況。

try (ServerSocket serverSocket = new ServerSocket(port)) {
 while (true) {
 Socket socket = serverSocket.accept();
 // ...
 }
} catch (IOException e) {
 e.printStackTrace();
}

併發服務器
在併發服務器中，監聽套接字會一直阻塞直到能夠接受連接，接受連接後，服務器會讓子線程/進程去處理已連接套接字，示意Java代碼如下。這種模式雖然是並行處理，可以不干擾服務端的監聽，但是由於每次新來一個請求就會產生一個新的線程去處理，出於資源的考慮很難應對高併發的情況。

try (ServerSocket serverSocket = new ServerSocket(port)) {
 while (true) {
 final Socket socket = serverSocket.accept();
 new Thread(() -> {
 // ...
 }).start();
 }
} catch (IOException e) {
 e.printStackTrace();
}

IO多路複用（事件驅動）
為了能在一個線程中處理多個連接，可以使用IO多路複用（事件驅動），典型的有Linux C中的select、poll和epoll，Java的Selector類等。以Selector為例，調用者在選擇器上為不同的連接註冊自己感興趣的事件（可讀/可寫/可接受/可連接），然後阻塞在select上，當事件發生時調用者便會得到通知，並且知道是哪個連接觸發了事件，以便可以進一步處理。
Selector實現的HTTP服務器示意如下：

 public class NioServer {
 private static final int BUFFER_SIZE = 512;
 private static final String HTTP_RESPONSE_BODY = "Hello wolrd\n";
 private static final String HTTP_RESPONSE_HEADER = "HTTP/1.1 200\r\n" +
 "Content-Type: text/html\r\n" + "Content-Length: " + HTTP_RESPONSE_BODY.length() + "\r\n\r\n";
 private static final String HTTP_RESPONSE = HTTP_RESPONSE_HEADER + HTTP_RESPONSE_BODY;
 
 // IO多路複用
 public void selector(int port) {
 try (ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
 Selector selector = Selector.open()) {
 serverSocketChannel.configureBlocking(false);
 serverSocketChannel.bind(new InetSocketAddress(port)); 

 serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
 while (true) {
 int readyChannels = selector.select();
 if (readyChannels == 0) {
 continue;
 }
 Set<selectionkey> selectedKeys = selector.selectedKeys();
 Iterator<selectionkey> iter = selectedKeys.iterator();
 while (iter.hasNext()) {
 SelectionKey key = iter.next();
 if (key.isAcceptable()) {
 SocketChannel channel = ((ServerSocketChannel) key.channel()).accept();
 System.out.println("accept: " + channel);
 channel.configureBlocking(false);
 channel.register(selector, SelectionKey.OP_READ);
 }
 if (key.isReadable()) {
 SocketChannel channel = (SocketChannel) key.channel();
 System.out.println("read: " + channel);
 ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
 int bytesRead = channel.read(buffer);
 while (bytesRead > 0) {
 buffer.flip();
 while (buffer.hasRemaining()) {
 System.out.print((char) buffer.get());
 }
 buffer.clear();
 bytesRead = channel.read(buffer);
 }
 ByteBuffer writeBuf = ByteBuffer.wrap(HTTP_RESPONSE.getBytes());
 while (writeBuf.hasRemaining()) {
 channel.write(writeBuf);
 }
 channel.close();
 }
 iter.remove();
 }
 }
 } catch (IOException e) {
 e.printStackTrace();
 }
 }
 }
/<selectionkey>/<selectionkey>