2. 程式人生 > >BIO和NIO

BIO和NIO

阿新 • • 發佈：2018-12-26

zedosu

關於BIO和NIO的理解

摘要: 關於BIO和NIO的理解

最近大概看了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. 1. package cn.nio;    
  2. 2.    
  3. 3. import java.io.IOException;    
  4. 4. import java.net.InetSocketAddress;    
  5. 5. import java.nio.ByteBuffer;    
  6. 6. import java.nio.channels.SelectionKey;    
  7. 7. import java.nio.channels.Selector;    
  8. 8. import java.nio.channels.ServerSocketChannel;    
  9. 9. import java.nio.channels.SocketChannel;    
  10. 10. import java.util.Iterator;    
  11. 11.    
  12. 12. /**  
  13. 13. * NIO服務端  
  14. 14. *  
  15. 15. */    
  16. 16. public class NIOServer {    
  17. 17.    //通道管理器    
  18. 18.    private Selector selector;    
  19. 19.    
  20. 20.    /**  
  21. 21.     * 獲得一個ServerSocket通道，並對該通道做一些初始化的工作  
  22. 22.     * @param port  繫結的埠號  
  23. 23.     * @throws IOException  
  24. 24.     */    
  25. 25.    public void initServer(int port) throws IOException {    
  26. 26.        // 獲得一個ServerSocket通道    
  27. 27.        ServerSocketChannel serverChannel = ServerSocketChannel.open();    
  28. 28.        // 設定通道為非阻塞    
  29. 29.        serverChannel.configureBlocking(false);    
  30. 30.        // 將該通道對應的ServerSocket繫結到port埠    
  31. 31.        serverChannel.socket().bind(new InetSocketAddress(port));    
  32. 32.        // 獲得一個通道管理器    
  33. 33.        this.selector = Selector.open();    
  34. 34.        //將通道管理器和該通道繫結，併為該通道註冊SelectionKey.OP_ACCEPT事件,註冊該事件後，    
  35. 35.        //當該事件到達時，selector.select()會返回，如果該事件沒到達selector.select()會一直阻塞。    
  36. 36.        serverChannel.register(selector, SelectionKey.OP_ACCEPT);    
  37. 37.    }    
  38. 38.    
  39. 39.    /**  
  40. 40.     * 採用輪詢的方式監聽selector上是否有需要處理的事件，如果有，則進行處理  
  41. 41.     * @throws IOException  
  42. 42.     */    
  43. 43.    @SuppressWarnings("unchecked")    
  44. 44.    public void listen() throws IOException {    
  45. 45.        System.out.println("服務端啟動成功！");    
  46. 46.        // 輪詢訪問selector    
  47. 47.        while (true) {    
  48. 48.            //當註冊的事件到達時，方法返回；否則,該方法會一直阻塞    
  49. 49.            selector.select();    
  50. 50.            // 獲得selector中選中的項的迭代器，選中的項為註冊的事件    
  51. 51.            Iterator ite = this.selector.selectedKeys().iterator();    
  52. 52.            while (ite.hasNext()) {    
  53. 53.                SelectionKey key = (SelectionKey) ite.next();    
  54. 54.                // 刪除已選的key,以防重複處理    
  55. 55.                ite.remove();    
  56. 56.                // 客戶端請求連線事件    
  57. 57.                if (key.isAcceptable()) {    
  58. 58.                    ServerSocketChannel server = (ServerSocketChannel) key    
  59. 59.                            .channel();    
  60. 60.                    // 獲得和客戶端連線的通道    
  61. 61.                    SocketChannel channel = server.accept();    
  62. 62.                    // 設定成非阻塞    
  63. 63.                    channel.configureBlocking(false);    
  64. 64.    
  65. 65.                    //在這裡可以給客戶端傳送資訊哦    
  66. 66.                    channel.write(ByteBuffer.wrap(new String("向客戶端傳送了一條資訊").getBytes()));    
  67. 67.                    //在和客戶端連線成功之後，為了可以接收到客戶端的資訊，需要給通道設定讀的許可權。    
  68. 68.                    channel.register(this.selector, SelectionKey.OP_READ);    
  69. 69.                        
  70. 70.                    // 獲得了可讀的事件    
  71. 71.                } else if (key.isReadable()) {    
  72. 72.                        read(key);    
  73. 73.                }    
  74. 74.    
  75. 75.            }    
  76. 76.    
  77. 77.        }    
  78. 78.    }    
  79. 79.    /**  
  80. 80.     * 處理讀取客戶端發來的資訊 的事件  
  81. 81.     * @param key  
  82. 82.     * @throws IOException   
  83. 83.     */    
  84. 84.    public void read(SelectionKey key) throws IOException{    
  85. 85.        // 伺服器可讀取訊息:得到事件發生的Socket通道    
  86. 86.        SocketChannel channel = (SocketChannel) key.channel();    
  87. 87.        // 建立讀取的緩衝區    
  88. 88.        ByteBuffer buffer = ByteBuffer.allocate(10);    
  89. 89.        channel.read(buffer);    
  90. 90.        byte[] data = buffer.array();    
  91. 91.        String msg = new String(data).trim();    
  92. 92.        System.out.println("服務端收到資訊："+msg);    
  93. 93.        ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());    
  94. 94.        channel.write(outBuffer);// 將訊息回送給客戶端    
  95. 95.    }    
  96. 96.        
  97. 97.    /**  
  98. 98.     * 啟動服務端測試  
  99. 99.     * @throws IOException   
  100. 100.     */    
  101. 101.    public static void main(String[] args) throws IOException {    
  102. 102.        NIOServer server = new NIOServer();    
  103. 103.        server.initServer(8000);    
  104. 104.        server.listen();    
  105. 105.    }    
  106. 106.    
  107. 107. }    

  
客戶端：

  1.  1. package cn.nio;    
  2. 2.    
  3. 3. import java.io.IOException;    
  4. 4. import java.net.InetSocketAddress;    
  5. 5. import java.nio.ByteBuffer;    
  6. 6. import java.nio.channels.SelectionKey;    
  7. 7. import java.nio.channels.Selector;    
  8. 8. import java.nio.channels.SocketChannel;    
  9. 9. import java.util.Iterator;    
  10. 10.    
  11. 11. /**  
  12. 12. * NIO客戶端  
  13. 13. *  
  14. 14. */    
  15. 15. public class NIOClient {    
  16. 16.    //通道管理器    
  17. 17.    private Selector selector;    
  18. 18.    
  19. 19.    /**  
  20. 20.     * 獲得一個Socket通道，並對該通道做一些初始化的工作  
  21. 21.     * @param ip 連線的伺服器的ip  
  22. 22.     * @param port  連線的伺服器的埠號           
  23. 23.     * @throws IOException  
  24. 24.     */    
  25. 25.    public void initClient(String ip,int port) throws IOException {    
  26. 26.        // 獲得一個Socket通道    
  27. 27.        SocketChannel channel = SocketChannel.open();    
  28. 28.        // 設定通道為非阻塞    
  29. 29.        channel.configureBlocking(false);    
  30. 30.        // 獲得一個通道管理器    
  31. 31.        this.selector = Selector.open();    
  32. 32.            
  33. 33.        // 客戶端連線伺服器,其實方法執行並沒有實現連線，需要在listen（）方法中調    
  34. 34.        //用channel.finishConnect();才能完成連線    
  35. 35.        channel.connect(new InetSocketAddress(ip,port));    
  36. 36.        //將通道管理器和該通道繫結，併為該通道註冊SelectionKey.OP_CONNECT事件。    
  37. 37.        channel.register(selector, SelectionKey.OP_CONNECT);    
  38. 38.    }    
  39. 39.    
  40. 40.    /**  
  41. 41.     * 採用輪詢的方式監聽selector上是否有需要處理的事件，如果有，則進行處理  
  42. 42.     * @throws IOException  
  43. 43.     */    
  44. 44.    @SuppressWarnings("unchecked")    
  45. 45.    public void listen() throws IOException {    
  46. 46.        // 輪詢訪問selector    
  47. 47.        while (true) {    
  48. 48.            selector.select();    
  49. 49.            // 獲得selector中選中的項的迭代器    
  50. 50.            Iterator ite = this.selector.selectedKeys().iterator();    
  51. 51.            while (ite.hasNext()) {    
  52. 52.                SelectionKey key = (SelectionKey) ite.next();    
  53. 53.                // 刪除已選的key,以防重複處理    
  54. 54.                ite.remove();    
  55. 55.                // 連線事件發生    
  56. 56.                if (key.isConnectable()) {    
  57. 57.                    SocketChannel channel = (SocketChannel) key    
  58. 58.                            .channel();    
  59. 59.                    // 如果正在連線，則完成連線    
  60. 60.                    if(channel.isConnectionPending()){    
  61. 61.                        channel.finishConnect();    
  62. 62.                            
  63. 63.                    }    
  64. 64.                    // 設定成非阻塞    
  65. 65.                    channel.configureBlocking(false);    
  66. 66.    
  67. 67.                    //在這裡可以給服務端傳送資訊哦    
  68. 68.                    channel.write(ByteBuffer.wrap(new String("向服務端傳送了一條資訊").getBytes()));    
  69. 69.                    //在和服務端連線成功之後，為了可以接收到服務端的資訊，需要給通道設定讀的許可權。    
  70. 70.                    channel.register(this.selector, SelectionKey.OP_READ);    
  71. 71.                        
  72. 72.                    // 獲得了可讀的事件    
  73. 73.                } else if (key.isReadable()) {    
  74. 74.                        read(key);    
  75. 75.                }    
  76. 76.    
  77. 77.            }    
  78. 78.    
  79. 79.        }    
  80. 80.    }    
  81. 81.    /**  
  82. 82.     * 處理讀取服務端發來的資訊 的事件  
  83. 83.     * @param key  
  84. 84.     * @throws IOException   
  85. 85.     */    
  86. 86.    public void read(SelectionKey key) throws IOException{    
  87. 87.        //和服務端的read方法一樣    
  88. 88.    }    
  89. 89.        
  90. 90.        
  91. 91.    /**  
  92. 92.     * 啟動客戶端測試  
  93. 93.     * @throws IOException   
  94. 94.     */    
  95. 95.    public static void main(String[] args) throws IOException {    
  96. 96.        NIOClient client = new NIOClient();    
  97. 97.        client.initClient("localhost",8000);    
  98. 98.        client.listen();    
  99. 99.    }    
  100. 100.    
  101. 101. }    
  102.    


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

	</div>
	<div class = "postDesc">posted @ <span id="post-date">2017-04-04 23:36</span> <a href='https://www.cnblogs.com/zedosu/'>zedosu</a> 閱讀(<span id="post_view_count">...</span>) 評論(<span id="post_comment_count">...</span>)  <a href ="https://i.cnblogs.com/EditPosts.aspx?postid=6666984" rel="nofollow">編輯</a> <a href="#" onclick="AddToWz(6666984);return false;">收藏</a></div>
</div>
<script type="text/javascript">var allowComments=true,cb_blogId=337523,cb_entryId=6666984,cb_blogApp=currentBlogApp,cb_blogUserGuid='e1dac851-2002-e711-845c-ac853d9f53ac',cb_entryCreatedDate='2017/4/4 23:36:00';loadViewCount(cb_entryId);var cb_postType=1;</script>

</div><!--end: forFlow -->
</div><!--end: mainContent 主體內容容器-->

<div id="sideBar">
	<div id="sideBarMain">

公告

		<div id="calendar"><div id="blog-calendar" style="display:none"></div><script type="text/javascript">loadBlogDefaultCalendar();</script></div>
		
		<DIV id="leftcontentcontainer">
			<div id="blog-sidecolumn"></div><script type="text/javascript">loadBlogSideColumn();</script>
		</DIV>
		
	</div><!--end: sideBarMain -->
</div><!--end: sideBar 側邊欄容器 -->
<div class="clear"></div>
</div><!--end: main -->
<div class="clear"></div>
<div id="footer">

Copyright ©2018 zedosu

原文地址：https://www.cnblogs.com/zedosu/p/6666984.html

相關推薦

談談我對java的BIO和NIO的學習的理解

首先io是人機互動的前提 是非常重要滴 java在早期只有bio 後面更新出來了nio nio的作用越來越重要 有的人稱nio為阻塞式io 這點我覺得很不嚴謹 而且對於阻塞與非阻塞的概念我看很多人的說法也不一致 在此我只說說我自己的認識 畢竟認知也是一個不斷提升和完善的

BIO和NIO

zedosu 關於BIO和NIO的理解 摘要:

AIO、BIO和NIO的區別詳解

IO讀寫時，多路複用機制都會依賴一個事件分離器，負責把源事件的IO分離出來，對應到read/write事件分離器。 事件分離器的兩種模式： 1. Reactor：同步IO 2. Proactor：非同步IO（重疊IO） Reactor 在Rea

Java IO：BIO和NIO區別及各自應用場景

引言BIO和NIO是兩種不同的網路通訊模型，現如今NIO已經大量應用在Jetty、ZooKeeper、Netty等開源框架中。一個面向流、一個面向緩衝區一個是阻塞式的、一個非阻塞一個沒有io多路複用器、一個有下面通過一個例子解釋兩者區別：假設當前服務端程式需要同時從與多個客戶

系統之間通訊方式（BIO和NIO的區別）（二）

4-3、NIO通訊框架 目前流行的NIO框架非常的多。在論壇上、網際網路上大家討論和使用最多的有以下幾種： 原生JAVA NIO框架：  JAVA NIO通訊框架基於多路複用IO原理，我們將詳細講解它的工作原理。 APACHE MINA 2：  是一個網路應用程

淺談 BIO和NIO和AIO 區別

引言 BIO和NIO是兩種不同的網路通訊模型，現如今NIO已經大量應用在Jetty、ZooKeeper、Netty等開源框架中。 一個面向流、一個面向緩衝區 一個是阻塞式的、一個非阻塞 一個沒有io多路複用器、一個有 下面通過一個例子解釋兩者區別： 假設當前服

BIO和NIO的區別

BIO：同步阻塞式IO，伺服器實現模式為一個連線一個執行緒，即客戶端有連線請求時伺服器端就需要啟動一個執行緒進行處理，如果這個連線不做任何事情會造成不必要的執行緒開銷，當然可以通過執行緒池機制改善。NIO：同步非阻塞式IO，伺服器實現模式為一個請求一個執行緒，即客戶端傳送的

阿裏面試題BIO和NIO數量問題附答案和代碼

hello config 試題 代碼 stream accept figure 我們 客戶端請求 一、問題 BIO 和 NIO 作為 Server 端，當建立了 10 個連接時，分別產生多少個線程？ 答案： 因為傳統的 IO 也就是 BIO 是同步線程堵塞的，所以每個連接都

阿里面試題BIO和NIO數量問題附答案和程式碼

開發十年，就只剩下這套架構體系了！ >>>   

從實踐角度重新理解BIO和NIO

前言 這段時間自己在看一些Java中BIO和NIO之類的東西，看了很多部落格，發現各種關於NIO的概念說的天花亂墜頭頭是道，可以說是非常的完整，但是整個看下來之後，自己對NIO還是一知半解的狀態，所以這篇文章不會提到很多的概念，而是站在一個實踐的角度，寫一些我自己關於NIO的見解，站在實踐過後的高度下再回去看

網路程式設計NIO：BIO和NIO

BIO BIO(Blocking I/O)，同步阻塞，實現模式為一個連線一個執行緒，即當有客戶端連線時，伺服器端需為其單獨分配一個執行緒，如果該連線不做任何操作就會造成不必要的執行緒開銷。BIO是傳統的Java io程式設計，其相關的類和介面在java.io 包下。 BIO適用於連線數目較小且固定的架構，對伺

BIO、NIO和AIO

IO的方式通常分為幾種，同步阻塞的BIO、同步非阻塞的NIO、非同步非阻塞的AIO。 一、BIO      在JDK1.4出來之前，我們建立網路連線的時候採用BIO模式，需要先在服務端啟動一個ServerSocket，然後在客戶端啟動Socket來對服務端進行通訊，預設情

BIO、NIO和AIO的區別、具體實現

一：理解同步：同步就是在發出一個*呼叫*時，在沒有得到結果之前，該*呼叫*就不返回，但是一旦呼叫返回，就得到返回值了。簡單的為：就是由*呼叫者*主動等待這個*呼叫*的結果。 二：非同步：*呼叫*在發出之後，這個呼叫就直接返回了，所以沒有返回結果；換句話說，當一個非同步過程呼

BIO、NIO、AIO 區別和應用場景

前邊簡單介紹過IO的基本情況  Java IO流 簡單回顧 對於IO我們應該非常熟悉了，IO不僅僅針對檔案的操作，網路程式設計socket的通訊，就是IO操作。 輸入、輸出流（InputStream、OutputStream）用於讀取或寫入位元組，如操作圖片、視訊等。

Java進階（五）Java I/O模型從BIO到NIO和Reactor模式

本文介紹了Java中的四種I/O模型，同步阻塞，同步非阻塞，多路複用，非同步阻塞。同時將NIO和BIO進行了對比，並詳細分析了基於NIO的Reactor模式，包括經典單執行緒模型以及多執行緒模式和多Reactor模式。 原創文章，轉載請務必將下面這段話置於文章開頭處（保留超連結）。 本文

Java中BIO、NIO、AIO的區別和應用場景

    學習IO，首先要明白四個東西。 1.同步         java自己去處理io。 2.非同步 java將io交給作業系統去處理，告訴快取區大小，處理完成回撥。 3.阻塞  使用阻塞IO時，Java呼叫會一直阻塞到讀寫完成才返回。 4.非阻塞 使用非阻塞IO時，如果不能立馬讀寫，Java呼叫會馬上返

BIO、NIO和AIO的區別（簡明版）

      一：事件分離器         在IO讀寫時，把 IO請求 與 讀寫操作 分離調配進行，需要用到事件分離器。根據處理機制的不同，事件分離器又分為：同步的Reactor和非同步的Proactor。         Reactor模型： - 應用程式

轉BIO，NIO和AIO講的很明白的文章

到底什麼是“IO Block” 很多人說BIO不好，會“block”，但到底什麼是IO的Block呢？考慮下面兩種情況： 用系統呼叫read從socket裡讀取一段資料 用系統呼叫read從一個磁碟檔案讀取一段資料到記憶體 如果你的直覺告訴你，這兩種都算“Block”，

結合程式碼詳細聊聊BIO，NIO和AIO

作者：大寬寬 1、到底什麼是“IO Block” 很多人說BIO不好，會“block”，但到底什麼是IO的Block呢？考慮下面兩種情況： 用系統呼叫read從socket裡讀取一段資料 用系統呼叫read從一個磁碟檔案讀取一段資料到記憶體 如果你的直覺告

Java的BIO、NIO和AIO介紹

1. I/O概念理解：同步/非同步、阻塞/非阻塞 一個IO操作其實分成了兩個步驟：發起IO請求和實際的IO操作。 同步IO和非同步IO的區別就在於第二個步驟是否阻塞，如果實際的IO讀寫阻塞請求程序，那麼就是同步IO。 阻塞IO和非阻塞IO的區別在於第一步，發