Netty权威指南（笔记一）

转载：http://blog.csdn.net/clarkkentyang/article/details/52529785

第一章（略）

第二章 NIO入门

2.1传统的BIO编程（同步阻塞I/O服务端通信模型【一客户一线程】）

网络编程的基本模型：Client/Server模型，也就是2个进程之间进行相互通信，其中服务端提供位置信息（绑定的IP地址和监听端口），客户端通过连接操作向服务端监听的地址发起连接请求，通过三次握手建立连接，如果连接建立成功，双方就可以通过网络套接字（Socket）进行通信。

传统同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口；Socket负责发起连接操作。连接成功之后，双方通过输入和输出流进行同步阻塞式通信。

缺点：缺乏弹性伸缩能力，当客户端并发访问量增加后，服务端的线程个数和客户端并发访问数呈1：1的正比关系，由于线程是Java虚拟机非常宝贵的系统资源，当线程数膨胀之后，系统的性能将急剧下降，随着并发访问量的继续增大，系统会发生线程堆栈溢出、创建新线程失败等问题，并最终导致进程宕机或者僵死，不能对外提供服务。

服务端代码：

1. <span style="white-space:pre">    </span>public static void main(String[] args) throws IOException {
2. int port = 8080;
3. if (args != null && args.length > 0) {
4. try {
5. port = Integer.valueOf(args[0]);
6. } catch (NumberFormatException e) {
7. // 采用默认值
8. }
9. }
10. ServerSocket server = null;
11. try {
12. server = new ServerSocket(port);
13. System.out.println("The time server is start in port : " + port);
14. Socket socket = null;
15. while (true) {
16. socket = server.accept();
17. new Thread(new TimeServerHandler(socket)).start();
18. }
19. } finally {
20. if (server != null) {
21. System.out.println("The time server close");
22. server.close();
23. server = null;
24. }
25. }
26. }

TimeServerHandler代码：

1. public class TimeServerHandler implements Runnable {
2. private Socket socket;
3. public TimeServerHandler(Socket socket) {
4. this.socket = socket;
5. }
6. /*
7. * (non-Javadoc)
8. *
9. * @see java.lang.Runnable#run()
10. */
11. @Override
12. public void run() {
13. BufferedReader in = null;
14. PrintWriter out = null;
15. try {
16. in = new BufferedReader(new InputStreamReader(
17. this.socket.getInputStream()));
18. out = new PrintWriter(this.socket.getOutputStream(), true);
19. String currentTime = null;
20. String body = null;
21. while (true) {
22. body = in.readLine();
23. if (body == null)
24. break;
25. System.out.println("The time server receive order : " + body);
26. currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new java.util.Date(
27. System.currentTimeMillis()).toString() : "BAD ORDER";
28. out.println(currentTime);
29. }
30. } catch (Exception e) {
31. if (in != null) {
32. try {
33. in.close();
34. } catch (IOException e1) {
35. e1.printStackTrace();
36. }
37. }
38. if (out != null) {
39. out.close();
40. out = null;
41. }
42. if (this.socket != null) {
43. try {
44. this.socket.close();
45. } catch (IOException e1) {
46. e1.printStackTrace();
47. }
48. this.socket = null;
49. }
50. }
51. }
52. }

客户端代码：

1. <span style="white-space:pre">    </span>public static void main(String[] args) {
2. int port = 8080;
3. if (args != null && args.length > 0) {
4. try {
5. port = Integer.valueOf(args[0]);
6. } catch (NumberFormatException e) {
7. // 采用默认值
8. }
9. }
10. Socket socket = null;
11. BufferedReader in = null;
12. PrintWriter out = null;
13. try {
14. socket = new Socket("127.0.0.1", port);
15. in = new BufferedReader(new InputStreamReader(
16. socket.getInputStream()));
17. out = new PrintWriter(socket.getOutputStream(), true);
18. out.println("QUERY TIME ORDER");
19. System.out.println("Send order 2 server succeed.");
20. String resp = in.readLine();
21. System.out.println("Now is : " + resp);
22. } catch (Exception e) {
23. e.printStackTrace();
24. } finally {
25. if (out != null) {
26. out.close();
27. out = null;
28. }
29. if (in != null) {
30. try {
31. in.close();
32. } catch (IOException e) {
33. e.printStackTrace();
34. }
35. in = null;
36. }
37. if (socket != null) {
38. try {
39. socket.close();
40. } catch (IOException e) {
41. e.printStackTrace();
42. }
43. socket = null;
44. }
45. }
46. }

2.2伪异步I/O编程

在BIO的基础上进行优化，后端通过一个线程池来处理多个客户端的请求接入，通过线程池可以灵活的调配线程资源，设置线程的最大值，防止由于海量并发接入导致线程耗尽。

服务端代码：

1. public static void main(String[] args) throws IOException {
2. int port = 8080;
3. if (args != null && args.length > 0) {
4. try {
5. port = Integer.valueOf(args[0]);
6. } catch (NumberFormatException e) {
7. // 采用默认值
8. }
9. }
10. ServerSocket server = null;
11. try {
12. server = new ServerSocket(port);
13. System.out.println("The time server is start in port : " + port);
14. Socket socket = null;
15. TimeServerHandlerExecutePool singleExecutor = new TimeServerHandlerExecutePool(
16. 50, 10000);// 创建IO任务线程池
17. while (true) {
18. socket = server.accept();
19. singleExecutor.execute(new TimeServerHandler(socket));
20. }
21. } finally {
22. if (server != null) {
23. System.out.println("The time server close");
24. server.close();
25. server = null;
26. }
27. }
28. }

连接池代码：

1. public class TimeServerHandlerExecutePool {
2. private ExecutorService executor;
3. public TimeServerHandlerExecutePool(int maxPoolSize, int queueSize) {
4. executor = new ThreadPoolExecutor(Runtime.getRuntime()
5. .availableProcessors(), maxPoolSize, 120L, TimeUnit.SECONDS,
6. new ArrayBlockingQueue<java.lang.Runnable>(queueSize));
7. }
8. public void execute(java.lang.Runnable task) {
9. executor.execute(task);
10. }
11. }

优点：避免了为每个请求都创建一个独立线程造成的线程资源耗尽问题。

缺点：但是由于它底层的通信依然采用同步阻塞模型，因此无法从跟本上解决问题。

2.3 NIO编程

NIO为New I/O的简称，也是非阻塞I/O。

INO提供了SocketChannel和ServerSocketChannel两种不同的套接字通道实现。这两种新增的通道都支持阻塞和非阻塞两种模式。开发人员可以根据自己需求选择合适的模式。一般来说，低负载，低并发的应用程序可以选择同步阻塞I/O以降低编程复杂度，但是对于高负载，高并发的网络应用，需要使用NIO的非阻塞模式进行开发。

2.3.1 NIO类库解析

1.缓冲区Buffer

最常用的缓冲区为ByteBuffer，提供了一组功能用于操作数组。除此之外，还有CharBuffer，ShortBuffer，IntBuffer，LongBuffer，FloatBuffer，DoubleBuffer。

2.通道Channel

是一个通道，主要通过它读取和写入数据。

Channel主要分为网络读写SelectableChannel和文件操作FileChannel

Netty主要涉及ServerSocketChannel和SocketChannel都是SelectableChannel的子类

3.多路复用器Selector

不断的扫描新的TCP连接接入、读和写事件的Channel，如果有，Channel就会处于就绪状态，被Selector轮询出来，然后通过selectionKey可以获取就绪Channel的集合，进行后续的I/O操作。

2.3.2 NIO源码

1.服务端代码

1. public static void main(String[] args) throws IOException {
2. int port = 8080;
3. if (args != null && args.length > 0) {
4. try {
5. port = Integer.valueOf(args[0]);
6. } catch (NumberFormatException e) {
7. // 采用默认值
8. }
9. }
10. MultiplexerTimeServer timeServer = new MultiplexerTimeServer(port);
11. new Thread(timeServer, "NIO-MultiplexerTimeServer-001").start();

2.MultiplexerTimeServer类

1. public class MultiplexerTimeServer implements Runnable {
2. private Selector selector;
3. private ServerSocketChannel servChannel;
4. private volatile boolean stop;
5. /**
6. * 初始化多路复用器、绑定监听端口
7. *
8. * @param port
9. */
10. public MultiplexerTimeServer(int port) {
11. try {
12. selector = Selector.open();
13. servChannel = ServerSocketChannel.open();
14. servChannel.configureBlocking(false);
15. servChannel.socket().bind(new InetSocketAddress(port), 1024);
16. servChannel.register(selector, SelectionKey.OP_ACCEPT);
17. System.out.println("The time server is start in port : " + port);
18. } catch (IOException e) {
19. e.printStackTrace();
20. System.exit(1);
21. }
22. }
23. public void stop() {
24. this.stop = true;
25. }
26. /*
27. * (non-Javadoc)
28. *
29. * @see java.lang.Runnable#run()
30. */
31. @Override
32. public void run() {
33. while (!stop) {
34. try {
35. selector.select(1000);
36. Set<SelectionKey> selectedKeys = selector.selectedKeys();
37. Iterator<SelectionKey> it = selectedKeys.iterator();
38. SelectionKey key = null;
39. while (it.hasNext()) {
40. key = it.next();
41. it.remove();
42. try {
43. handleInput(key);
44. } catch (Exception e) {
45. if (key != null) {
46. key.cancel();
47. if (key.channel() != null)
48. key.channel().close();
49. }
50. }
51. }
52. } catch (Throwable t) {
53. t.printStackTrace();
54. }
55. }
56. // 多路复用器关闭后，所有注册在上面的Channel和Pipe等资源都会被自动去注册并关闭，所以不需要重复释放资源
57. if (selector != null)
58. try {
59. selector.close();
60. } catch (IOException e) {
61. e.printStackTrace();
62. }
63. }
64. private void handleInput(SelectionKey key) throws IOException {
65. if (key.isValid()) {
66. // 处理新接入的请求消息
67. if (key.isAcceptable()) {
68. // Accept the new connection
69. ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
70. SocketChannel sc = ssc.accept();
71. sc.configureBlocking(false);
72. // Add the new connection to the selector
73. sc.register(selector, SelectionKey.OP_READ);
74. }
75. if (key.isReadable()) {
76. // Read the data
77. SocketChannel sc = (SocketChannel) key.channel();
78. ByteBuffer readBuffer = ByteBuffer.allocate(1024);
79. int readBytes = sc.read(readBuffer);
80. if (readBytes > 0) {
81. readBuffer.flip();
82. byte[] bytes = new byte[readBuffer.remaining()];
83. readBuffer.get(bytes);
84. String body = new String(bytes, "UTF-8");
85. System.out.println("The time server receive order : "
86. + body);
87. String currentTime = "QUERY TIME ORDER"
88. .equalsIgnoreCase(body) ? new java.util.Date(
89. System.currentTimeMillis()).toString()
90. : "BAD ORDER";
91. doWrite(sc, currentTime);
92. } else if (readBytes < 0) {
93. // 对端链路关闭
94. key.cancel();
95. sc.close();
96. } else
97. ; // 读到0字节，忽略
98. }
99. }
100. }
101. private void doWrite(SocketChannel channel, String response)
102. throws IOException {
103. if (response != null && response.trim().length() > 0) {
104. byte[] bytes = response.getBytes();
105. ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
106. writeBuffer.put(bytes);
107. writeBuffer.flip();
108. channel.write(writeBuffer);
109. }
110. }
111. }

3.客户端代码

1. public static void main(String[] args) {
2. int port = 8080;
3. if (args != null && args.length > 0) {
4. try {
5. port = Integer.valueOf(args[0]);
6. } catch (NumberFormatException e) {
7. // 采用默认值
8. }
9. }
10. new Thread(new TimeClientHandle("127.0.0.1", port), "TimeClient-001")
11. .start();
12. }

4.TimeClientHandle类

1. public class TimeClientHandle implements Runnable {
2. private String host;
3. private int port;
4. private Selector selector;
5. private SocketChannel socketChannel;
6. private volatile boolean stop;
7. public TimeClientHandle(String host, int port) {
8. this.host = host == null ? "127.0.0.1" : host;
9. this.port = port;
10. try {
11. selector = Selector.open();
12. socketChannel = SocketChannel.open();
13. socketChannel.configureBlocking(false);
14. } catch (IOException e) {
15. e.printStackTrace();
16. System.exit(1);
17. }
18. }
19. /*
20. * (non-Javadoc)
21. *
22. * @see java.lang.Runnable#run()
23. */
24. @Override
25. public void run() {
26. try {
27. doConnect();
28. } catch (IOException e) {
29. e.printStackTrace();
30. System.exit(1);
31. }
32. while (!stop) {
33. try {
34. selector.select(1000);
35. Set<SelectionKey> selectedKeys = selector.selectedKeys();
36. Iterator<SelectionKey> it = selectedKeys.iterator();
37. SelectionKey key = null;
38. while (it.hasNext()) {
39. key = it.next();
40. it.remove();
41. try {
42. handleInput(key);
43. } catch (Exception e) {
44. if (key != null) {
45. key.cancel();
46. if (key.channel() != null)
47. key.channel().close();
48. }
49. }
50. }
51. } catch (Exception e) {
52. e.printStackTrace();
53. System.exit(1);
54. }
55. }
56. // 多路复用器关闭后，所有注册在上面的Channel和Pipe等资源都会被自动去注册并关闭，所以不需要重复释放资源
57. if (selector != null)
58. try {
59. selector.close();
60. } catch (IOException e) {
61. e.printStackTrace();
62. }
63. }
64. private void handleInput(SelectionKey key) throws IOException {
65. if (key.isValid()) {
66. // 判断是否连接成功
67. SocketChannel sc = (SocketChannel) key.channel();
68. if (key.isConnectable()) {
69. if (sc.finishConnect()) {
70. sc.register(selector, SelectionKey.OP_READ);
71. doWrite(sc);
72. } else
73. System.exit(1);// 连接失败，进程退出
74. }
75. if (key.isReadable()) {
76. ByteBuffer readBuffer = ByteBuffer.allocate(1024);
77. int readBytes = sc.read(readBuffer);
78. if (readBytes > 0) {
79. readBuffer.flip();
80. byte[] bytes = new byte[readBuffer.remaining()];
81. readBuffer.get(bytes);
82. String body = new String(bytes, "UTF-8");
83. System.out.println("Now is : " + body);
84. this.stop = true;
85. } else if (readBytes < 0) {
86. // 对端链路关闭
87. key.cancel();
88. sc.close();
89. } else
90. ; // 读到0字节，忽略
91. }
92. }
93. }
94. private void doConnect() throws IOException {
95. // 如果直接连接成功，则注册到多路复用器上，发送请求消息，读应答
96. if (socketChannel.connect(new InetSocketAddress(host, port))) {
97. socketChannel.register(selector, SelectionKey.OP_READ);
98. doWrite(socketChannel);
99. } else
100. socketChannel.register(selector, SelectionKey.OP_CONNECT);
101. }
102. private void doWrite(SocketChannel sc) throws IOException {
103. byte[] req = "QUERY TIME ORDER".getBytes();
104. ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
105. writeBuffer.put(req);
106. writeBuffer.flip();
107. sc.write(writeBuffer);
108. if (!writeBuffer.hasRemaining())
109. System.out.println("Send order 2 server succeed.");
110. }
111. }

2.4 AIO编程

JDK7的产物，即NIO2.0。

1.服务端代码

1. public class TimeServer {
2. /**
3. * @param args
4. * @throws IOException
5. */
6. public static void main(String[] args) throws IOException {
7. int port = 8080;
8. if (args != null && args.length > 0) {
9. try {
10. port = Integer.valueOf(args[0]);
11. } catch (NumberFormatException e) {
12. // 采用默认值
13. }
14. }
15. AsyncTimeServerHandler timeServer = new AsyncTimeServerHandler(port);
16. new Thread(timeServer, "AIO-AsyncTimeServerHandler-001").start();
17. }
18. }

2.AsyncTimeServerHandler类

1. public class AsyncTimeServerHandler implements Runnable {
2. private int port;
3. CountDownLatch latch;
4. AsynchronousServerSocketChannel asynchronousServerSocketChannel;
5. public AsyncTimeServerHandler(int port) {
6. this.port = port;
7. try {
8. asynchronousServerSocketChannel = AsynchronousServerSocketChannel
9. .open();
10. asynchronousServerSocketChannel.bind(new InetSocketAddress(port));
11. System.out.println("The time server is start in port : " + port);
12. } catch (IOException e) {
13. e.printStackTrace();
14. }
15. }
16. /*
17. * (non-Javadoc)
18. *
19. * @see java.lang.Runnable#run()
20. */
21. @Override
22. public void run() {
23. latch = new CountDownLatch(1);
24. doAccept();
25. try {
26. latch.await();
27. } catch (InterruptedException e) {
28. e.printStackTrace();
29. }
30. }
31. public void doAccept() {
32. asynchronousServerSocketChannel.accept(this,
33. new AcceptCompletionHandler());
34. }
35. }

3.AcceptCompletionHandler类

1. public class AcceptCompletionHandler implements
2. CompletionHandler<AsynchronousSocketChannel, AsyncTimeServerHandler> {
3. @Override
4. public void completed(AsynchronousSocketChannel result,
5. AsyncTimeServerHandler attachment) {
6. attachment.asynchronousServerSocketChannel.accept(attachment, this);
7. ByteBuffer buffer = ByteBuffer.allocate(1024);
8. result.read(buffer, buffer, new ReadCompletionHandler(result));
9. }
10. @Override
11. public void failed(Throwable exc, AsyncTimeServerHandler attachment) {
12. exc.printStackTrace();
13. attachment.latch.countDown();
14. }
15. }

4.ReadCompletionHandler类

1. public class ReadCompletionHandler implements
2. CompletionHandler<Integer, ByteBuffer> {
3. private AsynchronousSocketChannel channel;
4. public ReadCompletionHandler(AsynchronousSocketChannel channel) {
5. if (this.channel == null)
6. this.channel = channel;
7. }
8. @Override
9. public void completed(Integer result, ByteBuffer attachment) {
10. attachment.flip();
11. byte[] body = new byte[attachment.remaining()];
12. attachment.get(body);
13. try {
14. String req = new String(body, "UTF-8");
15. System.out.println("The time server receive order : " + req);
16. String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(req) ? new java.util.Date(
17. System.currentTimeMillis()).toString() : "BAD ORDER";
18. doWrite(currentTime);
19. } catch (UnsupportedEncodingException e) {
20. e.printStackTrace();
21. }
22. }
23. private void doWrite(String currentTime) {
24. if (currentTime != null && currentTime.trim().length() > 0) {
25. byte[] bytes = (currentTime).getBytes();
26. ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
27. writeBuffer.put(bytes);
28. writeBuffer.flip();
29. channel.write(writeBuffer, writeBuffer,
30. new CompletionHandler<Integer, ByteBuffer>() {
31. @Override
32. public void completed(Integer result, ByteBuffer buffer) {
33. // 如果没有发送完成，继续发送
34. if (buffer.hasRemaining())
35. channel.write(buffer, buffer, this);
36. }
37. @Override
38. public void failed(Throwable exc, ByteBuffer attachment) {
39. try {
40. channel.close();
41. } catch (IOException e) {
42. // ingnore on close
43. }
44. }
45. });
46. }
47. }
48. @Override
49. public void failed(Throwable exc, ByteBuffer attachment) {
50. try {
51. this.channel.close();
52. } catch (IOException e) {
53. e.printStackTrace();
54. }
55. }
56. }

5.客户端代码

1. public class TimeClient {
2. /**
3. * @param args
4. */
5. public static void main(String[] args) {
6. int port = 8080;
7. if (args != null && args.length > 0) {
8. try {
9. port = Integer.valueOf(args[0]);
10. } catch (NumberFormatException e) {
11. // 采用默认值
12. }
13. }
14. new Thread(new AsyncTimeClientHandler("127.0.0.1", port),
15. "AIO-AsyncTimeClientHandler-001").start();
16. }
17. }

6.AsyncTimeClientHandler

1. public class AsyncTimeClientHandler implements
2. CompletionHandler<Void, AsyncTimeClientHandler>, Runnable {
3. private AsynchronousSocketChannel client;
4. private String host;
5. private int port;
6. private CountDownLatch latch;
7. public AsyncTimeClientHandler(String host, int port) {
8. this.host = host;
9. this.port = port;
10. try {
11. client = AsynchronousSocketChannel.open();
12. } catch (IOException e) {
13. e.printStackTrace();
14. }
15. }
16. @Override
17. public void run() {
18. latch = new CountDownLatch(1);
19. client.connect(new InetSocketAddress(host, port), this, this);
20. try {
21. latch.await();
22. } catch (InterruptedException e1) {
23. e1.printStackTrace();
24. }
25. try {
26. client.close();
27. } catch (IOException e) {
28. e.printStackTrace();
29. }
30. }
31. @Override
32. public void completed(Void result, AsyncTimeClientHandler attachment) {
33. byte[] req = "QUERY TIME ORDER".getBytes();
34. ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
35. writeBuffer.put(req);
36. writeBuffer.flip();
37. client.write(writeBuffer, writeBuffer,
38. new CompletionHandler<Integer, ByteBuffer>() {
39. @Override
40. public void completed(Integer result, ByteBuffer buffer) {
41. if (buffer.hasRemaining()) {
42. client.write(buffer, buffer, this);
43. } else {
44. ByteBuffer readBuffer = ByteBuffer.allocate(1024);
45. client.read(
46. readBuffer,
47. readBuffer,
48. new CompletionHandler<Integer, ByteBuffer>() {
49. @Override
50. public void completed(Integer result,
51. ByteBuffer buffer) {
52. buffer.flip();
53. byte[] bytes = new byte[buffer
54. .remaining()];
55. buffer.get(bytes);
56. String body;
57. try {
58. body = new String(bytes,
59. "UTF-8");
60. System.out.println("Now is : "
61. + body);
62. latch.countDown();
63. } catch (UnsupportedEncodingException e) {
64. e.printStackTrace();
65. }
66. }
67. @Override
68. public void failed(Throwable exc,
69. ByteBuffer attachment) {
70. try {
71. client.close();
72. latch.countDown();
73. } catch (IOException e) {
74. // ingnore on close
75. }
76. }
77. });
78. }
79. }
80. @Override
81. public void failed(Throwable exc, ByteBuffer attachment) {
82. try {
83. client.close();
84. latch.countDown();
85. } catch (IOException e) {
86. // ingnore on close
87. }
88. }
89. });
90. }
91. @Override
92. public void failed(Throwable exc, AsyncTimeClientHandler attachment) {
93. exc.printStackTrace();
94. try {
95. client.close();
96. latch.countDown();
97. } catch (IOException e) {
98. e.printStackTrace();
99. }
100. }
101. }

2.5  4中I/O对比