什么是NIO

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

緩沖區(qū)(Buffer)

緩沖區(qū)類型

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

ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer
各種類型的緩沖區(qū)中，都有一個對應類型的數(shù)組，如

ByteBuffer

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

IntBuffer

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

獲取緩沖區(qū)
通過allocate方法可以獲取一個對應緩沖區(qū)的對象，它是緩沖區(qū)類的一個靜態(tài)方法

例

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

核心屬性

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

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

capacity：緩沖區(qū)的容量。通過構造函數(shù)賦予，一旦設置，無法更改
limit：緩沖區(qū)的界限。位于limit 后的數(shù)據(jù)不可讀寫。緩沖區(qū)的限制不能為負，并且不能大于其容量
position：下一個讀寫位置的索引（類似PC）。緩沖區(qū)的位置不能為負，并且不能大于limit
mark：記錄當前position的值。position被改變后，可以通過調(diào)用reset() 方法恢復到mark的位置。
以上四個屬性必須滿足以下要求

mark <= position <= limit <= capacity

核心方法

put()方法

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

flip()方法

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

get()方法
get()方法會讀取緩沖區(qū)中的一個值
進行該操作后，position會+1，如果超過了limit則會拋出異常
rewind()方法
該方法只能在讀模式下使用
rewind()方法后，會恢復position、limit和capacity的值，變?yōu)檫M行get()前的值
clean()方法
clean()方法會將緩沖區(qū)中的各個屬性恢復為最初的狀態(tài)，position = 0, capacity = limit
此時緩沖區(qū)的數(shù)據(jù)依然存在，處于“被遺忘”狀態(tài)，下次進行寫操作時會覆蓋這些數(shù)據(jù)

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("放入前參數(shù)");
        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個數(shù)據(jù)");
        byte bt = 1;
        byteBuffer.put(bt);
        byteBuffer.put(bt);
        byteBuffer.put(bt);

        System.out.println("放入后參數(shù)");
        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("讀取一個數(shù)據(jù)");
        // 切換模式
        byteBuffer.flip();
        byteBuffer.get();

        System.out.println("讀取后參數(shù)");
        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("恢復后參數(shù)");
        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()------");
        // 清空緩沖區(qū)，這里只是恢復了各個屬性的值，但是緩沖區(qū)里的數(shù)據(jù)依然存在
        // 但是下次寫入的時候會覆蓋緩沖區(qū)中之前的數(shù)據(jù)
        byteBuffer.clear();
        System.out.println("清空后參數(shù)");
        System.out.println("position " + byteBuffer.position());
        System.out.println("limit " + byteBuffer.limit());
        System.out.println("capacity " + byteBuffer.capacity());
        System.out.println();
        System.out.println("清空后獲得數(shù)據(jù)");
        System.out.println(byteBuffer.get());

    }
}

放入前參數(shù)
position 0
limit 1024
capacity 1024

------put()------
放入3個數(shù)據(jù)
放入后參數(shù)
position 3
limit 1024
capacity 1024

------flip()-get()------
讀取一個數(shù)據(jù)
讀取后參數(shù)
position 1
limit 3
capacity 1024

------rewind()------
恢復后參數(shù)
position 0
limit 3
capacity 1024

------clear()------
清空后參數(shù)
position 0
limit 1024
capacity 1024

清空后獲得數(shù)據(jù)
1

Process finished with exit code 0

非直接緩沖區(qū)和直接緩沖區(qū)

非直接緩沖區(qū)

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

public static ByteBuffer allocate(int capacity) {
   if (capacity < 0)
   throw new IllegalArgumentException();

   // 在堆內(nèi)存中開辟空間
   return new HeapByteBuffer(capacity, capacity);
}

HeapByteBuffer(int cap, int lim) {        // package-private
   // new byte[cap] 創(chuàng)建數(shù)組，在堆內(nèi)存中開辟空間
   super(-1, 0, lim, cap, new byte[cap], 0);
   /*
   hb = new byte[cap];
   offset = 0;
   */
}

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

直接緩沖區(qū)

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

public static ByteBuffer allocateDirect(int capacity) {
   return new DirectByteBuffer(capacity);
}

DirectByteBuffer(int cap) {                   // package-private
   ...
   // 申請物理內(nèi)存
   boolean pa = VM.isDirectMemoryPageAligned();
   ...
}

直接緩沖區(qū)通過在操作系統(tǒng)和JVM之間創(chuàng)建物理內(nèi)存映射文件加快緩沖區(qū)數(shù)據(jù)讀/寫入物理磁盤的速度。放到物理內(nèi)存映射文件中的數(shù)據(jù)就不歸應用程序控制了，操作系統(tǒng)會自動將物理內(nèi)存映射文件中的數(shù)據(jù)寫入到物理內(nèi)存中。

通道(Channel)

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

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

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

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

Java Channel

本地文件IO
FileChannel
網(wǎng)絡IO
SocketChanel、ServerSocketChannel：用于TCP傳輸
DatagramChannel：用于UDP傳輸
獲得通道的方法
對象調(diào)用getChannel() 方法
獲取通道的一種方式是對支持通道的對象調(diào)用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();

        // 網(wǎng)絡通道
        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()+非直接緩沖區(qū)

getChannel()獲得通道
allocate()獲得非直接緩沖區(qū)
通過非直接緩沖區(qū)讀寫數(shù)據(jù)，需要通過通道來傳輸緩沖區(qū)里的數(shù)據(jù)

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();

            // 獲得緩沖區(qū)，用于在通道中傳輸數(shù)據(jù)
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

            // 循環(huán)將字節(jié)數(shù)據(jù)放入到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()+直接緩沖區(qū)

通過open獲得通道
通過FileChannel.map()獲取直接緩沖區(qū)
使用直接緩沖區(qū)時，無需通過通道來傳輸數(shù)據(jù)，直接將數(shù)據(jù)放在緩沖區(qū)內(nèi)即可

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是因為后面獲取直接緩沖區(qū)時模式為READ_WRITE模式
       // CREATE是因為要創(chuàng)建新的文件
       FileChannel outChannel = FileChannel.open(Paths.get(""), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);

       // 獲得直接緩沖區(qū)
       MappedByteBuffer inMapBuf = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
       MappedByteBuffer outMapBuf = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());

       // 字節(jié)數(shù)組
       byte[] bytes = new byte[inMapBuf.limit()];

       // 因為是直接緩沖區(qū)，可以直接將數(shù)據(jù)放入到內(nèi)存映射文件，無需通過通道傳輸
       inMapBuf.get(bytes);
       outMapBuf.put(bytes);

       // 關閉緩沖區(qū)，這里沒有用try-catch-finally
       inChannel.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是因為后面獲取直接緩沖區(qū)時模式為READ_WRITE模式
  // CREATE是因為要創(chuàng)建新的文件
  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();
}

直接緩沖區(qū)VS非直接緩沖區(qū)

// getChannel() + 非直接緩沖區(qū)耗時
708
// open() + 直接緩沖區(qū)耗時
115
// channel transferTo channel耗時
47

直接緩沖區(qū)的讀寫速度雖然很快，但是會占用很多很多內(nèi)存空間。如果文件過大，會使得計算機運行速度變慢

分散和聚集

分散讀取

分散讀?。⊿cattering Reads）是指從Channel 中讀取的數(shù)據(jù)“分散”到多個Buffer 中。

注意：按照緩沖區(qū)的順序，從Channel 中讀取的數(shù)據(jù)依次將 Buffer 填滿。

聚集寫入

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

按照緩沖區(qū)的順序，寫入position 和limit 之間的數(shù)據(jù)到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();

        // 獲得多個緩沖區(qū)，并且放入到緩沖區(qū)數(shù)組中
        ByteBuffer byteBuffer1 = ByteBuffer.allocate(50);
        ByteBuffer byteBuffer2 = ByteBuffer.allocate(1024);
        ByteBuffer[] byteBuffers = {byteBuffer1, byteBuffer2};

        // 分散讀取
        inChannel.read(byteBuffers);

        byteBuffer1.flip();
        byteBuffer2.flip();

        // 聚集寫入
        outChannel.write(byteBuffers);
    }
}

非阻塞式網(wǎng)絡通信

概念
底層原理可見：操作系統(tǒng)-文件IO

舉個你去飯?zhí)贸燥埖睦?，你好??戶程序，飯?zhí)煤?操作系統(tǒng)。

阻塞 I/O 好?，
你去飯?zhí)贸燥?，但是飯?zhí)玫牟诉€沒做好，然后你就?直在那?等啊等，

等了好??段時間終于等到飯?zhí)冒⒁贪巡硕肆顺鰜恚〝?shù)據(jù)準備的過程），

但是你還得繼續(xù)等阿姨把菜（內(nèi)核空間）打到你的飯盒?（?戶空間），

經(jīng)歷完這兩個過程，你才可以離開。

?阻塞 I/O 好?，
你去了飯?zhí)?，問阿姨菜做好了沒有，阿姨告訴你沒，

你就離開了，過??分鐘，你?來，

飯?zhí)脝柊⒁?，阿姨說做好了，于是阿姨幫你把菜打到你的飯盒?，這個過程你是得等待的。

基于?阻塞的 I/O 多路復?好?，
你去飯?zhí)贸燥?，發(fā)現(xiàn)有?排窗?，飯?zhí)冒⒁谈嬖V你這些窗?都還沒做好菜，

等做好了再通知你，于是等啊等（ select 調(diào)?中），過了?會阿姨通知你菜做好了，

但是不知道哪個窗?的菜做好了，你??看吧。

于是你只能?個?個窗?去確認，后?發(fā)現(xiàn) 5 號窗?菜做好了，

于是你讓 5 號窗?的阿姨幫你打菜到飯盒?，這個打菜的過程你是要等待的，雖然時間不?。

打完菜后，你?然就可以離開了。

異步 I/O 好?，
你讓飯?zhí)冒⒁虒⒉俗龊貌巡舜虻斤埡?后，把飯盒送到你?前，整個過程你都不需要任何等待。

阻塞式網(wǎng)絡通信

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 {
        // 創(chuàng)建客戶端通道
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 2022));

        // 讀取信息 D:\\bizhi\\bizhi202008\\wallhaven-kwp2qq.jpg
        FileChannel fileChannel = FileChannel.open(Paths.get("D:\\\\bizhi\\\\bizhi202008\\\\wallhaven-kwp2qq.jpg"), StandardOpenOption.READ);

        // 創(chuàng)建緩沖區(qū)
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        // 寫入數(shù)據(jù)
        while (fileChannel.read(byteBuffer) != -1) {
            byteBuffer.flip();
            socketChannel.write(byteBuffer);
            byteBuffer.clear();
        }

        fileChannel.close();
        socketChannel.close();
    }

    public static void server() throws IOException {
        // 創(chuàng)建服務端通道
        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();

        // 創(chuàng)建緩沖區(qū)
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        while (socketChannel.read(byteBuffer) != -1) {
            byteBuffer.flip();
            fileChannel.write(byteBuffer);
            byteBuffer.clear();
        }

        socketChannel.close();
        fileChannel.close();
        serverSocketChannel.close();
    }
}

非阻塞式網(wǎng)絡通信

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();
            // 獲得事件的key
            while (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 可以同時監(jiān)控多個SelectableChannel 的IO 狀況，也就是說，利用Selector 可使一個單獨的線程管理多個Channel。Selector 是非阻塞IO 的核心。

選擇器的創(chuàng)建

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

綁定選擇器

通過調(diào)用通道的register方法可以綁定選擇器，register方法有兩個參數(shù)

Selector：即綁定哪個選擇器
ops：監(jiān)聽事件類型。ops有4個值可以選擇，為SelectionKey的靜態(tài)屬性

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

SelectionKey

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

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

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

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

什么是NIO

緩沖區(qū)(Buffer)

緩沖區(qū)類型

核心屬性

核心方法

mark()和reset()方法

非直接緩沖區(qū)和直接緩沖區(qū)

非直接緩沖區(qū)

直接緩沖區(qū)

通道(Channel)

Java Channel

分散和聚集

非阻塞式網(wǎng)絡通信

阻塞式網(wǎng)絡通信

選擇器

相關閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

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

什么是NIO

緩沖區(qū)(Buffer)

緩沖區(qū)類型

核心屬性

核心方法

mark()和reset()方法

非直接緩沖區(qū)和直接緩沖區(qū)

非直接緩沖區(qū)

直接緩沖區(qū)

通道(Channel)

Java Channel

分散和聚集

非阻塞式網(wǎng)絡通信

阻塞式網(wǎng)絡通信

選擇器

相關閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

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