关于BIO和NIO的理解

时间 2019-11-16

标签关于 bio nio 理解栏目 Netty 繁體版

原文原文链接

摘要: 关于BIO和NIO的理解java

最近大概看了ZooKeeper和Mina的源码发现都是用Java NIO实现的，因此有必要搞清楚什么是NIO。下面是我结合网络资料本身总结的，为了节约时间图示随便画的，能达意就行。编程

简介：服务器

BIO：同步阻塞式IO，服务器实现模式为一个链接一个线程，即客户端有链接请求时服务器端就须要启动一个线程进行处理，若是这个链接不作任何事情会形成没必要要的线程开销，固然能够经过线程池机制改善。
NIO：同步非阻塞式IO，服务器实现模式为一个请求一个线程，即客户端发送的链接请求都会注册到多路复用器上，多路复用器轮询到链接有I/O请求时才启动一个线程进行处理。
AIO(NIO.2)：异步非阻塞式IO，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

BIO
同步阻塞式IO，相信每个学习过操做系统网络编程或者任何语言的网络编程的人都很熟悉，在while循环中服务端会调用accept方法等待接收客户端的链接请求，一旦接收到一个链接请求，就能够创建通讯套接字在这个通讯套接字上进行读写操做，此时不能再接收其余客户端链接请求，只能等待同当前链接的客户端的操做执行完成。
若是BIO要可以同时处理多个客户端请求，就必须使用多线程，即每次accept阻塞等待来自客户端请求，一旦受到链接请求就创建通讯套接字同时开启一个新的线程来处理这个套接字的数据读写请求，而后马上又继续accept等待其余客户端链接请求，即为每个客户端链接请求都建立一个线程来单独处理，大概原理图就像这样：

虽然此时服务器具有了高并发能力，即可以同时处理多个客户端请求了，可是却带来了一个问题，随着开启的线程数目增多，将会消耗过多的内存资源，致使服务器变慢甚至崩溃，NIO能够必定程度解决这个问题。网络

NIO
同步非阻塞式IO，关键是采用了事件驱动的思想来实现了一个多路转换器。
NIO与BIO最大的区别就是只须要开启一个线程就能够处理来自多个客户端的IO事件，这是怎么作到的呢？
就是多路复用器，能够监听来自多个客户端的IO事件：
A. 若服务端监听到客户端链接请求，便为其创建通讯套接字(java中就是通道)，而后返回继续监听，若同时有多个客户端链接请求到来也能够所有收到，依次为它们都创建通讯套接字。
B. 若服务端监听到来自已经建立了通讯套接字的客户端发送来的数据，就会调用对应接口处理接收到的数据，若同时有多个客户端发来数据也能够依次进行处理。
C. 监听多个客户端的链接请求和接收数据请求同时还能监听本身时候有数据要发送。

总之就是在一个线程中就能够调用多路复用接口（java中是select）阻塞同时监听来自多个客户端的IO请求，一旦有收到IO请求就调用对应函数处理。

各自应用场景

到这里你也许已经发现，一旦有请求到来(无论是几个同时到仍是只有一个到)，都会调用对应IO处理函数处理，因此：多线程

（1）NIO适合处理链接数目特别多，可是链接比较短（轻操做）的场景，Jetty，Mina，ZooKeeper等都是基于java nio实现。并发

（2）BIO方式适用于链接数目比较小且固定的场景，这种方式对服务器资源要求比较高，并发局限于应用中。异步

附录：下面附上一个别人写的java NIO的例子。
服务端：

1. package cn.nio;
2.
3. import java.io.IOException;
4. import java.net.InetSocketAddress;
5. import java.nio.ByteBuffer;
6. import java.nio.channels.SelectionKey;
7. import java.nio.channels.Selector;
8. import java.nio.channels.ServerSocketChannel;
9. import java.nio.channels.SocketChannel;
10. import java.util.Iterator;
11.
12. /**
13. * NIO服务端
14. *
15. */
16. public class NIOServer {
17. //通道管理器
18. private Selector selector;
19.
20. /**
21. * 得到一个ServerSocket通道，并对该通道作一些初始化的工做
22. * @param port 绑定的端口号
23. * @throws IOException
24. */
25. public void initServer(int port) throws IOException {
26. // 得到一个ServerSocket通道
27. ServerSocketChannel serverChannel = ServerSocketChannel.open();
28. // 设置通道为非阻塞
29. serverChannel.configureBlocking(false);
30. // 将该通道对应的ServerSocket绑定到port端口
31. serverChannel.socket().bind(new InetSocketAddress(port));
32. // 得到一个通道管理器
33. this.selector = Selector.open();
34. //将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
35. //当该事件到达时，selector.select()会返回，若是该事件没到达selector.select()会一直阻塞。
36. serverChannel.register(selector, SelectionKey.OP_ACCEPT);
37. }
38.
39. /**
40. * 采用轮询的方式监听selector上是否有须要处理的事件，若是有，则进行处理
41. * @throws IOException
42. */
43. @SuppressWarnings("unchecked")
44. public void listen() throws IOException {
45. System.out.println("服务端启动成功！");
46. // 轮询访问selector
47. while (true) {
48. //当注册的事件到达时，方法返回；不然,该方法会一直阻塞
49. selector.select();
50. // 得到selector中选中的项的迭代器，选中的项为注册的事件
51. Iterator ite = this.selector.selectedKeys().iterator();
52. while (ite.hasNext()) {
53. SelectionKey key = (SelectionKey) ite.next();
54. // 删除已选的key,以防重复处理
55. ite.remove();
56. // 客户端请求链接事件
57. if (key.isAcceptable()) {
58. ServerSocketChannel server = (ServerSocketChannel) key
59. .channel();
60. // 得到和客户端链接的通道
61. SocketChannel channel = server.accept();
62. // 设置成非阻塞
63. channel.configureBlocking(false);
64.
65. //在这里能够给客户端发送信息哦
66. channel.write(ByteBuffer.wrap(new String("向客户端发送了一条信息").getBytes()));
67. //在和客户端链接成功以后，为了能够接收到客户端的信息，须要给通道设置读的权限。
68. channel.register(this.selector, SelectionKey.OP_READ);
69.
70. // 得到了可读的事件
71. } else if (key.isReadable()) {
72. read(key);
73. }
74.
75. }
76.
77. }
78. }
79. /**
80. * 处理读取客户端发来的信息的事件
81. * @param key
82. * @throws IOException
83. */
84. public void read(SelectionKey key) throws IOException{
85. // 服务器可读取消息:获得事件发生的Socket通道
86. SocketChannel channel = (SocketChannel) key.channel();
87. // 建立读取的缓冲区
88. ByteBuffer buffer = ByteBuffer.allocate(10);
89. channel.read(buffer);
90. byte[] data = buffer.array();
91. String msg = new String(data).trim();
92. System.out.println("服务端收到信息："+msg);
93. ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());
94. channel.write(outBuffer);// 将消息回送给客户端
95. }
96.
97. /**
98. * 启动服务端测试
99. * @throws IOException
100. */
101. public static void main(String[] args) throws IOException {
102. NIOServer server = new NIOServer();
103. server.initServer(8000);
104. server.listen();
105. }
106.
107. }

客户端：

1. package cn.nio;
2.
3. import java.io.IOException;
4. import java.net.InetSocketAddress;
5. import java.nio.ByteBuffer;
6. import java.nio.channels.SelectionKey;
7. import java.nio.channels.Selector;
8. import java.nio.channels.SocketChannel;
9. import java.util.Iterator;
10.
11. /**
12. * NIO客户端
13. *
14. */
15. public class NIOClient {
16. //通道管理器
17. private Selector selector;
18.
19. /**
20. * 得到一个Socket通道，并对该通道作一些初始化的工做
21. * @param ip 链接的服务器的ip
22. * @param port 链接的服务器的端口号
23. * @throws IOException
24. */
25. public void initClient(String ip,int port) throws IOException {
26. // 得到一个Socket通道
27. SocketChannel channel = SocketChannel.open();
28. // 设置通道为非阻塞
29. channel.configureBlocking(false);
30. // 得到一个通道管理器
31. this.selector = Selector.open();
32.
33. // 客户端链接服务器,其实方法执行并无实现链接，须要在listen（）方法中调
34. //用channel.finishConnect();才能完成链接
35. channel.connect(new InetSocketAddress(ip,port));
36. //将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_CONNECT事件。
37. channel.register(selector, SelectionKey.OP_CONNECT);
38. }
39.
40. /**
41. * 采用轮询的方式监听selector上是否有须要处理的事件，若是有，则进行处理
42. * @throws IOException
43. */
44. @SuppressWarnings("unchecked")
45. public void listen() throws IOException {
46. // 轮询访问selector
47. while (true) {
48. selector.select();
49. // 得到selector中选中的项的迭代器
50. Iterator ite = this.selector.selectedKeys().iterator();
51. while (ite.hasNext()) {
52. SelectionKey key = (SelectionKey) ite.next();
53. // 删除已选的key,以防重复处理
54. ite.remove();
55. // 链接事件发生
56. if (key.isConnectable()) {
57. SocketChannel channel = (SocketChannel) key
58. .channel();
59. // 若是正在链接，则完成链接
60. if(channel.isConnectionPending()){
61. channel.finishConnect();
62.
63. }
64. // 设置成非阻塞
65. channel.configureBlocking(false);
66.
67. //在这里能够给服务端发送信息哦
68. channel.write(ByteBuffer.wrap(new String("向服务端发送了一条信息").getBytes()));
69. //在和服务端链接成功以后，为了能够接收到服务端的信息，须要给通道设置读的权限。
70. channel.register(this.selector, SelectionKey.OP_READ);
71.
72. // 得到了可读的事件
73. } else if (key.isReadable()) {
74. read(key);
75. }
76.
77. }
78.
79. }
80. }
81. /**
82. * 处理读取服务端发来的信息的事件
83. * @param key
84. * @throws IOException
85. */
86. public void read(SelectionKey key) throws IOException{
87. //和服务端的read方法同样
88. }
89.
90.
91. /**
92. * 启动客户端测试
93. * @throws IOException
94. */
95. public static void main(String[] args) throws IOException {
96. NIOClient client = new NIOClient();
97. client.initClient("localhost",8000);
98. client.listen();
99. }
100.
101. }

http://blog.csdn.net/jiyiqinlovexx/article/details/42619097

1. 关于BIO和NIO的理解
2. 关于IO、BIO、NIO的理解
3. 了解NIO和BIO
4. BIO,NIO,AIO(NIO2)的理解
5. 关于三大IO的理解:AIO,BIO,NIO
6. tomcat的nio和bio
7. 关于BIO、NIO、AIO的区别
8. BIO和NIO
9. BIO NIO 和Netty
10. 理解 JAVA BIO与NIO、AIO
更多相关文章...
• Spring使用AspectJ开发AOP：基于XML和基于Annotation - Spring教程
• MyBatis的工作原理 - MyBatis教程
• 适用于PHP初学者的学习线路和建议
• ☆基于Java Instrument的Agent实现