華為二面！！！面試官直接問我Java中到底什么是NIO？這不是直接送分題？？？

• 什么是NIO
• 緩沖區(Buffer)
• • 緩沖區類型
  • 獲取緩沖區
  • 核心屬性
  • 核心方法
• 非直接緩沖區和直接緩沖區
• • 非直接緩沖區
  • 直接緩沖區
• 通道(Channel)
• • Java Channel
  • • 獲得通道的方法
    • • 對象調用getChannel() 方法
      • getChannel()+非直接緩沖區
      • open()+直接緩沖區
      • 通道間直接傳輸
      • 直接緩沖區VS非直接緩沖區
  • 分散和聚集
• 非阻塞式網絡通信
• • 概念
  • 阻塞式網絡通信
  • 非阻塞式網絡通信
  • • 選擇器

什么是NIO

Java NIO（New IO）是從Java 1.4版本開始引入的一個新的IO API，可以替代標準的Java IO API。NIO與原來的IO有同樣的作用和目的，但是使用的方式完全不同，NIO支持面向緩沖區的、基于通道的IO操作。NIO將以更加高效的方式進行文件的讀寫操作。

IONIO

面向流(Stream Oriented)	面向緩沖區(Buffer Oriented)
阻塞IO(Blocking IO)	非阻塞IO(NonBlocking IO)
	選擇器(Selectors)

底層原理可見：操作系統-文件IO

緩沖區(Buffer)

緩沖區類型

Buffer 就像一個數組，可以保存多個相同類型的數據。根據數據類型不同(boolean 除外) ，有以下Buffer 常用子類

• ByteBuffer
• CharBuffer
• ShortBuffer
• IntBuffer
• LongBuffer
• FloatBuffer
• DoubleBuffer

各種類型的緩沖區中，都有一個對應類型的數組，如

ByteBuffer

final byte[] hb; // Non-null only for heap buffersCopy

IntBuffer

final int[] hb; // Non-null only for heap buffers

獲取緩沖區

通過allocate方法可以獲取一個對應緩沖區的對象，它是緩沖區類的一個靜態方法

例

// 獲取一個容量大小為1024字節的字節緩沖區 ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

核心屬性

緩沖區的父類Buffer中有幾個核心屬性，如下

// Invariants: mark <= position <= limit <= capacity private int mark = -1; private int position = 0; private int limit; private int capacity;Copy

• capacity：緩沖區的容量。通過構造函數賦予，一旦設置，無法更改
• limit：緩沖區的界限。位于limit 后的數據不可讀寫。緩沖區的限制不能為負，并且不能大于其容量
• position：下一個讀寫位置的索引（類似PC）。緩沖區的位置不能為負，并且不能大于limit
• mark：記錄當前position的值。position被改變后，可以通過調用reset() 方法恢復到mark的位置。

以上四個屬性必須滿足以下要求

mark <= position <= limit <= capacity

核心方法

put()方法

• put()方法可以將一個數據放入到緩沖區中。
• 進行該操作后，postition的值會+1，指向下一個可以放入的位置。capacity = limit ，為緩沖區容量的值。

flip()方法

• flip()方法會切換對緩沖區的操作模式，由寫->讀 / 讀->寫
• 進行該操作后
  • 如果是寫模式->讀模式，position = 0 ， limit 指向最后一個元素的下一個位置，capacity不變
  • 如果是讀->寫，則恢復為put()方法中的值

get()方法

• get()方法會讀取緩沖區中的一個值
• 進行該操作后，position會+1，如果超過了limit則會拋出異常

rewind()方法

• 該方法只能在讀模式下使用
• rewind()方法后，會恢復position、limit和capacity的值，變為進行get()前的值

clean()方法

• clean()方法會將緩沖區中的各個屬性恢復為最初的狀態，position = 0, capacity = limit
• 此時緩沖區的數據依然存在，處于“被遺忘”狀態，下次進行寫操作時會覆蓋這些數據

mark()和reset()方法

• mark()方法會將postion的值保存到mark屬性中
• reset()方法會將position的值改為mark中保存的值

使用展示

import java.nio.ByteBuffer;public class demo1 {public static void main(String[] args) {ByteBuffer byteBuffer = ByteBuffer.allocate(1024);System.out.println("放入前參數");System.out.println("position " + byteBuffer.position());System.out.println("limit " + byteBuffer.limit());System.out.println("capacity " + byteBuffer.capacity());System.out.println();System.out.println("------put()------");System.out.println("放入3個數據");byte bt = 1;byteBuffer.put(bt);byteBuffer.put(bt);byteBuffer.put(bt);System.out.println("放入后參數");System.out.println("position " + byteBuffer.position());System.out.println("limit " + byteBuffer.limit());System.out.println("capacity " + byteBuffer.capacity());System.out.println();System.out.println("------flip()-get()------");System.out.println("讀取一個數據");// 切換模式byteBuffer.flip();byteBuffer.get();System.out.println("讀取后參數");System.out.println("position " + byteBuffer.position());System.out.println("limit " + byteBuffer.limit());System.out.println("capacity " + byteBuffer.capacity());System.out.println();System.out.println("------rewind()------");byteBuffer.rewind();System.out.println("恢復后參數");System.out.println("position " + byteBuffer.position());System.out.println("limit " + byteBuffer.limit());System.out.println("capacity " + byteBuffer.capacity());System.out.println();System.out.println("------clear()------");// 清空緩沖區，這里只是恢復了各個屬性的值，但是緩沖區里的數據依然存在// 但是下次寫入的時候會覆蓋緩沖區中之前的數據byteBuffer.clear();System.out.println("清空后參數");System.out.println("position " + byteBuffer.position());System.out.println("limit " + byteBuffer.limit());System.out.println("capacity " + byteBuffer.capacity());System.out.println();System.out.println("清空后獲得數據");System.out.println(byteBuffer.get());} } 放入前參數 position 0 limit 1024 capacity 1024------put()------ 放入3個數據 放入后參數 position 3 limit 1024 capacity 1024------flip()-get()------ 讀取一個數據 讀取后參數 position 1 limit 3 capacity 1024------rewind()------ 恢復后參數 position 0 limit 3 capacity 1024------clear()------ 清空后參數 position 0 limit 1024 capacity 1024清空后獲得數據 1Process finished with exit code 0

非直接緩沖區和直接緩沖區

非直接緩沖區

通過allocate()方法獲取的緩沖區都是非直接緩沖區。這些緩沖區是建立在JVM堆內存之中的。

public static ByteBuffer allocate(int capacity) {if (capacity < 0)throw new IllegalArgumentException();// 在堆內存中開辟空間return new HeapByteBuffer(capacity, capacity); }HeapByteBuffer(int cap, int lim) { // package-private// new byte[cap] 創建數組，在堆內存中開辟空間super(-1, 0, lim, cap, new byte[cap], 0);/*hb = new byte[cap];offset = 0;*/ }

通過非直接緩沖區，想要將數據寫入到物理磁盤中，或者是從物理磁盤讀取數據。都需要經過JVM和操作系統，數據在兩個地址空間中傳輸時，會copy一份保存在對方的空間中。所以費直接緩沖區的讀取效率較低.。

直接緩沖區

只有ByteBuffer可以獲得直接緩沖區，通過allocateDirect()獲取的緩沖區為直接緩沖區，這些緩沖區是建立在物理內存之中的。

public static ByteBuffer allocateDirect(int capacity) {return new DirectByteBuffer(capacity); }DirectByteBuffer(int cap) { // package-private...// 申請物理內存boolean pa = VM.isDirectMemoryPageAligned();... }

直接緩沖區通過在操作系統和JVM之間創建物理內存映射文件加快緩沖區數據讀/寫入物理磁盤的速度。放到物理內存映射文件中的數據就不歸應用程序控制了，操作系統會自動將物理內存映射文件中的數據寫入到物理內存中。

通道(Channel)

Channel由java.nio.channels 包定義的。Channel 表示IO 源與目標打開的連接。Channel 類似于傳統的“流”。只不過Channel 本身不能直接訪問數據，Channel 只能與Buffer 進行交互 。

應用程序進行讀寫操作調用函數時，底層調用的操作系統提供給用戶的讀寫API，調用這些API時會生成對應的指令，CPU則會執行這些指令。在計算機剛出現的那段時間，所有讀寫請求的指令都有CPU去執行，過多的讀寫請求會導致CPU無法去執行其他命令，從而CPU的利用率降低。

后來，DMA(Direct Memory Access，直接存儲器訪問)出現了。當IO請求傳到計算機底層時，DMA會向CPU請求，讓DMA去處理這些IO操作，從而可以讓CPU去執行其他指令。DMA處理IO操作時，會請求獲取總線的使用權。當IO請求過多時，會導致大量總線用于處理IO請求，從而降低效率 。

于是便有了Channel(通道)，Channel相當于一個專門用于IO操作的獨立處理器，它具有獨立處理IO請求的能力，當有IO請求時，它會自行處理這些IO請求 。

Java Channel

• 本地文件IO
  • FileChannel
• 網絡IO
  • SocketChanel、ServerSocketChannel：用于TCP傳輸
  • DatagramChannel：用于UDP傳輸

獲得通道的方法

對象調用getChannel() 方法

獲取通道的一種方式是對支持通道的對象調用getChannel() 方法。支持通道的類如下：

• FileInputStream
• FileOutputStream
• RandomAccessFile
• DatagramSocket
• Socket
• ServerSocket

例子：

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.net.DatagramSocket; import java.net.ServerSocket; import java.net.Socket; import java.nio.channels.DatagramChannel; import java.nio.channels.FileChannel; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.nio.file.Paths;public class demo2 {public static void main(String[] args) throws IOException {// 本地通道FileInputStream fileInputStream = new FileInputStream("zwt");FileChannel channel1 = fileInputStream.getChannel();FileOutputStream fileOutputStream = new FileOutputStream("zwt");FileChannel channel2 = fileOutputStream.getChannel();// 網絡通道Socket socket = new Socket();SocketChannel channel3 = socket.getChannel();ServerSocket serverSocket = new ServerSocket();ServerSocketChannel channel4 = serverSocket.getChannel();DatagramSocket datagramSocket = new DatagramSocket();DatagramChannel channel5 = datagramSocket.getChannel();// 最后要關閉通道FileChannel open = FileChannel.open(Paths.get("zwt"));SocketChannel open1 = SocketChannel.open();} }

getChannel()+非直接緩沖區

• getChannel()獲得通道
• allocate()獲得非直接緩沖區

通過非直接緩沖區讀寫數據，需要通過通道來傳輸緩沖區里的數據

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.FileChannel;public class demo4 {public static void main(String[] args) {FileInputStream is = null;FileOutputStream os = null;// 獲得通道FileChannel inChannel = null;FileChannel outChannel = null;// 利用 try-catch-finally 保證關閉try {is = new FileInputStream("");os = new FileOutputStream("");// 獲得通道inChannel = is.getChannel();outChannel = os.getChannel();// 獲得緩沖區，用于在通道中傳輸數據ByteBuffer byteBuffer = ByteBuffer.allocate(1024);// 循環將字節數據放入到buffer中，然后寫入磁盤中while (inChannel.read(byteBuffer) != -1) {// 切換模式byteBuffer.flip();outChannel.write(byteBuffer);byteBuffer.clear();}} catch (IOException e) {e.printStackTrace();} finally {if (inChannel != null) {try {inChannel.close();} catch (IOException e) {e.printStackTrace();}}if (outChannel != null) {try {outChannel.close();} catch (IOException e) {e.printStackTrace();}}if (is != null) {try {is.close();} catch (IOException e) {e.printStackTrace();}}if (os != null) {try {os.close();} catch (IOException e) {e.printStackTrace();}}}} }

open()+直接緩沖區

• 通過open獲得通道
• 通過FileChannel.map()獲取直接緩沖區

使用直接緩沖區時，無需通過通道來傳輸數據，直接將數據放在緩沖區內即可

import java.io.IOException; import java.nio.MappedByteBuffer; import java.nio.channels.FileChannel; import java.nio.file.Paths; import java.nio.file.StandardOpenOption;public class demo5 {public static void main(String[] args) throws IOException {// 通過open()方法來獲得通道FileChannel inChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ);// outChannel需要為 READ WRITE CREATE模式// READ WRITE是因為后面獲取直接緩沖區時模式為READ_WRITE模式// CREATE是因為要創建新的文件FileChannel outChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);// 獲得直接緩沖區MappedByteBuffer inMapBuf = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());MappedByteBuffer outMapBuf = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());// 字節數組byte[] bytes = new byte[inMapBuf.limit()];// 因為是直接緩沖區，可以直接將數據放入到內存映射文件，無需通過通道傳輸inMapBuf.get(bytes);outMapBuf.put(bytes);// 關閉緩沖區，這里沒有用try-catch-finallyinChannel.close();outChannel.close();} }

通道間直接傳輸

public static void channelToChannel() throws IOException {long start = System.currentTimeMillis();// 通過open()方法來獲得通道FileChannel inChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ);// outChannel需要為 READ WRITE CREATE模式// READ WRITE是因為后面獲取直接緩沖區時模式為READ_WRITE模式// CREATE是因為要創建新的文件FileChannel outChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);// 通道間直接傳輸inChannel.transferTo(0, inChannel.size(), outChannel);// 對應的還有transferFrom// outChannel.transferFrom(inChannel, 0, inChannel.size());inChannel.close();outChannel.close(); }

直接緩沖區VS非直接緩沖區

// getChannel() + 非直接緩沖區耗時 708 // open() + 直接緩沖區耗時 115 // channel transferTo channel耗時 47直接緩沖區的讀寫速度雖然很快，但是會占用很多很多內存空間。如果文件過大，會使得計算機運行速度變慢

分散和聚集

分散讀取

分散讀取（Scattering Reads）是指從Channel 中讀取的數據“分散”到多個Buffer 中。

注意：按照緩沖區的順序，從Channel 中讀取的數據依次將 Buffer 填滿。

聚集寫入

聚集寫入（Gathering Writes）是指將多個Buffer 中的數據“聚集”到Channel。

按照緩沖區的順序，寫入position 和limit 之間的數據到Channel。

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.FileChannel;public class demo6 {public static void main(String[] args) throws IOException {FileInputStream is = new FileInputStream("");FileOutputStream os = new FileOutputStream("");FileChannel inChannel = is.getChannel();FileChannel outChannel = os.getChannel();// 獲得多個緩沖區，并且放入到緩沖區數組中ByteBuffer byteBuffer1 = ByteBuffer.allocate(50);ByteBuffer byteBuffer2 = ByteBuffer.allocate(1024);ByteBuffer[] byteBuffers = {byteBuffer1, byteBuffer2};// 分散讀取inChannel.read(byteBuffers);byteBuffer1.flip();byteBuffer2.flip();// 聚集寫入outChannel.write(byteBuffers);} }

非阻塞式網絡通信

概念

底層原理可見：操作系統-文件IO

比喻：

舉個你去飯堂吃飯的例?，你好??戶程序，飯堂好?操作系統。阻塞 I/O 好?， 你去飯堂吃飯，但是飯堂的菜還沒做好，然后你就?直在那?等啊等，等了好??段時間終于等到飯堂阿姨把菜端了出來（數據準備的過程），但是你還得繼續等阿姨把菜（內核空間）打到你的飯盒?（?戶空間），經歷完這兩個過程，你才可以離開。?阻塞 I/O 好?， 你去了飯堂，問阿姨菜做好了沒有，阿姨告訴你沒，你就離開了，過??分鐘，你?來，飯堂問阿姨，阿姨說做好了，于是阿姨幫你把菜打到你的飯盒?，這個過程你是得等待的。基于?阻塞的 I/O 多路復?好?， 你去飯堂吃飯，發現有?排窗?，飯堂阿姨告訴你這些窗?都還沒做好菜，等做好了再通知你，于是等啊等（ select 調?中），過了?會阿姨通知你菜做好了，但是不知道哪個窗?的菜做好了，你??看吧。于是你只能?個?個窗?去確認，后?發現 5 號窗?菜做好了，于是你讓 5 號窗?的阿姨幫你打菜到飯盒?，這個打菜的過程你是要等待的，雖然時間不?。打完菜后，你?然就可以離開了。異步 I/O 好?， 你讓飯堂阿姨將菜做好并把菜打到飯盒?后，把飯盒送到你?前，整個過程你都不需要任何等待。

阻塞式網絡通信

package NIOAndBIO;import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.nio.file.Paths; import java.nio.file.StandardOpenOption;public class BIO {public static void main(String[] args) throws IOException {Thread thread1 = new Thread(() -> {try {server();} catch (IOException e) {e.printStackTrace();}});Thread thread2 = new Thread(() -> {try {client();} catch (IOException e) {e.printStackTrace();}});thread1.start();thread2.start();}public static void client() throws IOException {// 創建客戶端通道SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 2022));// 讀取信息 D:\\bizhi\\bizhi202008\\wallhaven-kwp2qq.jpgFileChannel fileChannel = FileChannel.open(Paths.get("D:\\\\bizhi\\\\bizhi202008\\\\wallhaven-kwp2qq.jpg"), StandardOpenOption.READ);// 創建緩沖區ByteBuffer byteBuffer = ByteBuffer.allocate(1024);// 寫入數據while (fileChannel.read(byteBuffer) != -1) {byteBuffer.flip();socketChannel.write(byteBuffer);byteBuffer.clear();}fileChannel.close();socketChannel.close();}public static void server() throws IOException {// 創建服務端通道ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();FileChannel fileChannel = FileChannel.open(Paths.get("D:\\\\bizhi\\\\bizhi202008\\\\wallhaven-kwp2qq.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);// 綁定鏈接serverSocketChannel.bind(new InetSocketAddress(2022));// 獲取客戶端的通道SocketChannel socketChannel = serverSocketChannel.accept();// 創建緩沖區ByteBuffer byteBuffer = ByteBuffer.allocate(1024);while (socketChannel.read(byteBuffer) != -1) {byteBuffer.flip();fileChannel.write(byteBuffer);byteBuffer.clear();}socketChannel.close();fileChannel.close();serverSocketChannel.close();} }

非阻塞式網絡通信

package NIOAndBIO;import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Iterator; import java.util.Scanner;public class NIO {public static void main(String[] args) {Thread thread1 = new Thread(()->{try {server();} catch (IOException e) {e.printStackTrace();}});Thread thread2 = new Thread(()->{try {client();} catch (IOException e) {e.printStackTrace();}});thread1.start();thread2.start();}public static void client() throws IOException {SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 2020));// 設置為非阻塞模式socketChannel.configureBlocking(false);ByteBuffer byteBuffer = ByteBuffer.allocate(1024);Scanner scanner = new Scanner(System.in);while (scanner.hasNext()) {String str = scanner.next();byteBuffer.put(str.getBytes());byteBuffer.flip();socketChannel.write(byteBuffer);byteBuffer.clear();}byteBuffer.clear();socketChannel.close();}public static void server() throws IOException {ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();serverSocketChannel.configureBlocking(false);serverSocketChannel.bind(new InetSocketAddress(2020));// 獲得選擇器Selector selector = Selector.open();// 將通道注冊到選擇器中，設定為接收操作serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);// 輪詢接受while (selector.select() > 0) {Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();// 獲得事件的keywhile (iterator.hasNext()) {SelectionKey key = iterator.next();if (key.isAcceptable()) {SocketChannel socketChannel = serverSocketChannel.accept();socketChannel.configureBlocking(false);socketChannel.register(selector, SelectionKey.OP_READ);} else if (key.isReadable()) {// 從選擇器中獲取通道SocketChannel socketChannel = (SocketChannel) key.channel();ByteBuffer byteBuffer = ByteBuffer.allocate(10);while (socketChannel.read(byteBuffer) != -1) {int len = byteBuffer.limit();byteBuffer.flip();System.out.println(new String(byteBuffer.array(), 0, len));byteBuffer.clear();}socketChannel.close();}iterator.remove();}}serverSocketChannel.close();} }

選擇器

選擇器（Selector）是SelectableChannle 對象的多路復用器，Selector 可以同時監控多個SelectableChannel 的IO 狀況，也就是說，利用Selector 可使一個單獨的線程管理多個Channel。Selector 是非阻塞IO 的核心 。

選擇器的創建

// 創建一個選擇器 Selector selector = Selector.open();

綁定選擇器

通過調用通道的register方法可以綁定選擇器，register方法有兩個參數

• Selector：即綁定哪個選擇器
• ops：監聽事件類型。ops有4個值可以選擇，為SelectionKey的靜態屬性

// 讓選擇器監聽一種狀態 myChannel.register(selector, SelectionKey.OP_READ); // 讓選擇器監聽多種狀態 myChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_ACCEPT);

SelectionKey

表示SelectableChannel 和Selector 之間的注冊關系。每次向選擇器注冊通道時就會選擇一個事件(選擇鍵)。選擇鍵包含兩個表示為整數值的操作集。操作集的每一位都表示該鍵的通道所支持的一類可選擇操作。

總結

以上是生活随笔為你收集整理的华为二面！！！面试官直接问我Java中到底什么是NIO？这不是直接送分题？？？的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。