JDK10都發布了，nio你瞭解多少？

時間  2019-11-18
標籤 jdk10 jdk 發佈 nio 瞭解 多少 欄目 Java 简体版
原文   原文鏈接

前言

只有光頭才能變強html

回顧前面：java

原本我預想是先來回顧一下傳統的IO模式的，將傳統的IO模式的相關類理清楚(由於IO的類不少)。編程

可是，發如今整理的過程已經有不少優秀的文章了，而我本身來整理的話可能達不到他們的水平。而且傳統的IO估計你們都會用，而NIO就不必定了。小程序

下面我就貼幾張我認爲整理比較優秀的思惟導圖(下面會給出圖片來源地址，你們可前往閱讀)：微信小程序

按操做方式分類結構圖：api

字節流的輸入和輸出對照圖：數組

字符流的輸入和輸出對照圖：緩存

按操做對象分類結構圖：安全

上述圖片原文地址，知乎做者@小明：服務器

還有閱讀傳統IO源碼的優秀文章：

相信你們看完上面兩個給出的連接+理解了包裝模式就是這麼簡單啦，傳統的IO應該就沒什麼事啦~~

而NIO對於我來講能夠說是挺陌生的，在當初學的時候是接觸過的。可是一直沒有用它，因此停留認知：nio是jdk1.4開始有的，比傳統IO高級。

相信不少初學者都跟我同樣，對NIO是不太瞭解的。而咱們如今jdk10都已經發布了，jdk1.4的nio都不知道，這有點說不過去了。

因此我花了幾天去了解NIO的核心知識點，期間看了《Java 編程思想》和《瘋狂Java 講義》的nio模塊。可是，會發現看完了以後仍是很迷，不知道NIO這是幹嗎用的，而網上的資料與書上的知識點沒有很好地對應。

  • 網上的資料不少都以IO的五種模型爲基礎來說解NIO，而IO這五種模型其中又涉及到了不少概念：同步/異步/阻塞/非阻塞/多路複用，而不一樣的人又有不一樣的理解方式。
  • 還有涉及到了unix的select/epoll/poll/pselect，fd這些關鍵字，沒有相關基礎的人看起來簡直是天書
  • 這就致使了在初學時認爲nio遠不可及

我在找資料的過程當中也收藏了好多講解NIO的資料，這篇文章就是以初學的角度來理解NIO。也算是我這兩天看NIO的一個總結吧。

  • 但願你們能夠看了以後知道什麼是NIO，NIO的核心知識點是什麼，會使用NIO~

那麼接下來就開始吧，若是文章有錯誤的地方請你們多多包涵，不吝在評論區指正哦~

聲明：本文使用JDK1.8

1、NIO的概述

JDK 1.4中的java.nio.*包中引入新的Java I/O庫，其目的是提升速度。實際上，「舊」的I/O包已經使用NIO從新實現過，即便咱們不顯式的使用NIO編程，也能從中受益。

  • nio翻譯成 no-blocking io 或者 new io 都無所謂啦，都說得通~

在《Java編程思想》讀到「即便咱們不顯式的使用NIO編程，也能從中受益」的時候，我是挺在乎的，因此：咱們測試一下使用NIO複製文件和傳統IO複製文件的性能：

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class SimpleFileTransferTest {

    private long transferFile(File source, File des) throws IOException {
        long startTime = System.currentTimeMillis();

        if (!des.exists())
            des.createNewFile();

        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(source));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(des));

        //將數據源讀到的內容寫入目的地--使用數組
        byte[] bytes = new byte[1024 * 1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }

        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }

    private long transferFileWithNIO(File source, File des) throws IOException {
        long startTime = System.currentTimeMillis();

        if (!des.exists())
            des.createNewFile();

        RandomAccessFile read = new RandomAccessFile(source, "rw");
        RandomAccessFile write = new RandomAccessFile(des, "rw");

        FileChannel readChannel = read.getChannel();
        FileChannel writeChannel = write.getChannel();


        ByteBuffer byteBuffer = ByteBuffer.allocate(1024 * 1024);//1M緩衝區

        while (readChannel.read(byteBuffer) > 0) {
            byteBuffer.flip();
            writeChannel.write(byteBuffer);
            byteBuffer.clear();
        }

        writeChannel.close();
        readChannel.close();
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }

    public static void main(String[] args) throws IOException {
        SimpleFileTransferTest simpleFileTransferTest = new SimpleFileTransferTest();
        File sourse = new File("F:\\電影\\[電影天堂www.dygod.cn]猜火車-cd1.rmvb");
        File des = new File("X:\\Users\\ozc\\Desktop\\io.avi");
        File nio = new File("X:\\Users\\ozc\\Desktop\\nio.avi");

        long time = simpleFileTransferTest.transferFile(sourse, des);
        System.out.println(time + "：普通字節流時間");

        long timeNio = simpleFileTransferTest.transferFileWithNIO(sourse, nio);
        System.out.println(timeNio + "：NIO時間");


    }

}

我分別測試了文件大小爲13M，40M，200M的：

1.1爲何要使用NIO

能夠看到使用過NIO從新實現過的傳統IO根本不虛，在大文件下效果還比NIO要好(固然了，我的幾回的測試，或許不是很準)

  • 而NIO要有必定的學習成本，也沒有傳統IO那麼好理解。

那這意味着咱們能夠不使用/學習NIO了嗎？

答案是否認的，IO操做每每在兩個場景下會用到：

  • 文件IO
  • 網絡IO

NIO的魅力：在網絡中使用IO就能夠體現出來了！

  • 後面會說到網絡中使用NIO，不急哈~

2、NIO快速入門

首先咱們來看看IO和NIO的區別：

  • 可簡單認爲：IO是面向流的處理，NIO是面向塊(緩衝區)的處理
    • 面向流的I/O 系統一次一個字節地處理數據。
    • 一個面向塊(緩衝區)的I/O系統以塊的形式處理數據。

NIO主要有三個核心部分組成：

  • buffer緩衝區
  • Channel管道
  • Selector選擇器

2.1buffer緩衝區和Channel管道

在NIO中並非以流的方式來處理數據的，而是以buffer緩衝區和Channel管道配合使用來處理數據。

簡單理解一下：

  • Channel管道比做成鐵路，buffer緩衝區比做成火車(運載着貨物)

而咱們的NIO就是經過Channel管道運輸着存儲數據的Buffer緩衝區的來實現數據的處理！

  • 要時刻記住：Channel不與數據打交道，它只負責運輸數據。與數據打交道的是Buffer緩衝區
    • Channel-->運輸
    • Buffer-->數據

相對於傳統IO而言，流是單向的。對於NIO而言，有了Channel管道這個概念，咱們的讀寫都是雙向的(鐵路上的火車能從廣州去北京、天然就能從北京返還到廣州)！

2.1.1buffer緩衝區核心要點

咱們來看看Buffer緩衝區有什麼值得咱們注意的地方。

Buffer是緩衝區的抽象類：

其中ByteBuffer是用得最多的實現類(在管道中讀寫字節數據)。

拿到一個緩衝區咱們每每會作什麼？很簡單，就是讀取緩衝區的數據/寫數據到緩衝區中。因此，緩衝區的核心方法就是:

  • put()
  • get()

Buffer類維護了4個核心變量屬性來提供關於其所包含的數組的信息。它們是：

  • 容量Capacity
    • 緩衝區可以容納的數據元素的最大數量。容量在緩衝區建立時被設定，而且永遠不能被改變。(不能被改變的緣由也很簡單，底層是數組嘛)
  • 上界Limit
    • 緩衝區裏的數據的總數，表明了當前緩衝區中一共有多少數據。
  • 位置Position
    • 下一個要被讀或寫的元素的位置。Position會自動由相應的 get( )和 put( )函數更新。
  • 標記Mark
    • 一個備忘位置。用於記錄上一次讀寫的位置。

2.1.2buffer代碼演示

首先展現一下是如何建立緩衝區的，核心變量的值是怎麼變化的。

public static void main(String[] args) {

        // 建立一個緩衝區
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        // 看一下初始時4個核心變量的值
        System.out.println("初始時-->limit--->"+byteBuffer.limit());
        System.out.println("初始時-->position--->"+byteBuffer.position());
        System.out.println("初始時-->capacity--->"+byteBuffer.capacity());
        System.out.println("初始時-->mark--->" + byteBuffer.mark());

        System.out.println("--------------------------------------");

        // 添加一些數據到緩衝區中
        String s = "Java3y";
        byteBuffer.put(s.getBytes());

        // 看一下初始時4個核心變量的值
        System.out.println("put完以後-->limit--->"+byteBuffer.limit());
        System.out.println("put完以後-->position--->"+byteBuffer.position());
        System.out.println("put完以後-->capacity--->"+byteBuffer.capacity());
        System.out.println("put完以後-->mark--->" + byteBuffer.mark());
    }

運行結果：

如今我想要從緩存區拿數據，怎麼拿呀？？NIO給了咱們一個flip()方法。這個方法能夠改動position和limit的位置！

仍是上面的代碼，咱們flip()一下後，再看看4個核心屬性的值會發生什麼變化：

很明顯的是：

  • limit變成了position的位置了
  • 而position變成了0

看到這裏的同窗可能就會想到了：當調用完filp()時：limit是限制讀到哪裏，而position是從哪裏讀

通常咱們稱filp()爲「切換成讀模式」

  • 每當要從緩存區的時候讀取數據時，就調用filp()「切換成讀模式」。

切換成讀模式以後，咱們就能夠讀取緩衝區的數據了：

// 建立一個limit()大小的字節數組(由於就只有limit這麼多個數據可讀)
        byte[] bytes = new byte[byteBuffer.limit()];

        // 將讀取的數據裝進咱們的字節數組中
        byteBuffer.get(bytes);

        // 輸出數據
        System.out.println(new String(bytes, 0, bytes.length));

隨後輸出一下核心變量的值看看：

讀完咱們還想寫數據到緩衝區，那就使用clear()函數，這個函數會「清空」緩衝區：

  • 數據沒有真正被清空，只是被遺忘掉了

2.1.3FileChannel通道核心要點

Channel通道只負責傳輸數據、不直接操做數據的。操做數據都是經過Buffer緩衝區來進行操做！

// 1. 經過本地IO的方式來獲取通道
        FileInputStream fileInputStream = new FileInputStream("F:\\3yBlog\\JavaEE經常使用框架\\Elasticsearch就是這麼簡單.md");

        // 獲得文件的輸入通道
        FileChannel inchannel = fileInputStream.getChannel();

        // 2. jdk1.7後經過靜態方法.open()獲取通道
        FileChannel.open(Paths.get("F:\\3yBlog\\JavaEE經常使用框架\\Elasticsearch就是這麼簡單2.md"), StandardOpenOption.WRITE);

使用FileChannel配合緩衝區實現文件複製的功能：

使用內存映射文件的方式實現文件複製的功能(直接操做緩衝區)：

通道之間經過transfer()實現數據的傳輸(直接操做緩衝區)：

2.1.4直接與非直接緩衝區

  • 非直接緩衝區是須要通過一個：copy的階段的(從內核空間copy到用戶空間)
  • 直接緩衝區不須要通過copy階段，也能夠理解成--->內存映射文件，(上面的圖片也有過例子)。

使用直接緩衝區有兩種方式：

  • 緩衝區建立的時候分配的是直接緩衝區
  • 在FileChannel上調用map()方法，將文件直接映射到內存中建立

2.1.5scatter和gather、字符集

這個知識點我感受用得挺少的，不過不少教程都有說這個知識點，我也拿過來講說吧：

  • 分散讀取(scatter)：將一個通道中的數據分散讀取到多個緩衝區中
  • 彙集寫入(gather)：將多個緩衝區中的數據集中寫入到一個通道中

分散讀取

彙集寫入

字符集(只要編碼格式和解碼格式一致，就沒問題了)

3、IO模型理解

文件的IO就告一段落了，咱們來學習網絡中的IO~~~爲了更好地理解NIO，咱們先來學習一下IO的模型~

根據UNIX網絡編程對I/O模型的分類，在UNIX能夠概括成5種I/O模型：

  • 阻塞I/O
  • 非阻塞I/O
  • I/O多路複用
  • 信號驅動I/O
  • 異步I/O

3.0學習I/O模型須要的基礎

3.0.1文件描述符

Linux 的內核將全部外部設備都看作一個文件來操做，對一個文件的讀寫操做會調用內核提供的系統命令(api)，返回一個file descriptor（fd，文件描述符）。而對一個socket的讀寫也會有響應的描述符，稱爲socket fd（socket文件描述符），描述符就是一個數字，指向內核中的一個結構體（文件路徑，數據區等一些屬性）。

  • 因此說：在Linux下對文件的操做是利用文件描述符(file descriptor)來實現的。

3.0.2用戶空間和內核空間

爲了保證用戶進程不能直接操做內核（kernel），保證內核的安全，操心繫統將虛擬空間劃分爲兩部分

  • 一部分爲內核空間。
  • 一部分爲用戶空間。

3.0.3I/O運行過程

咱們來看看IO在系統中的運行是怎麼樣的(咱們以read爲例)

能夠發現的是：當應用程序調用read方法時，是須要等待的--->從內核空間中找數據，再將內核空間的數據拷貝到用戶空間的。

  • 這個等待是必要的過程！

下面只講解用得最多的3個I/0模型：

  • 阻塞I/O
  • 非阻塞I/O
  • I/O多路複用

3.1阻塞I/O模型

在進程(用戶)空間中調用recvfrom，其系統調用直到數據包到達且被複制到應用進程的緩衝區中或者發生錯誤時才返回，在此期間一直等待。

3.2非阻塞I/O模型

recvfrom從應用層到內核的時候，若是沒有數據就直接返回一個EWOULDBLOCK錯誤，通常都對非阻塞I/O模型進行輪詢檢查這個狀態，看內核是否是有數據到來。

3.3I/O複用模型

前面也已經說了：在Linux下對文件的操做是利用文件描述符(file descriptor)來實現的。

在Linux下它是這樣子實現I/O複用模型的：

  • 調用select/poll/epoll/pselect其中一個函數，傳入多個文件描述符，若是有一個文件描述符就緒，則返回，不然阻塞直到超時。

好比poll()函數是這樣子的：int poll(struct pollfd *fds,nfds_t nfds, int timeout);

其中 pollfd 結構定義以下：

struct pollfd {
    int fd;         /* 文件描述符 */
    short events;         /* 等待的事件 */
    short revents;       /* 實際發生了的事件 */
};

  • （1）當用戶進程調用了select，那麼整個進程會被block；
  • （2）而同時，kernel會「監視」全部select負責的socket；
  • （3）當任何一個socket中的數據準備好了，select就會返回；
  • （4）這個時候用戶進程再調用read操做，將數據從kernel拷貝到用戶進程(空間)。
  • 因此，I/O 多路複用的特色是經過一種機制一個進程能同時等待多個文件描述符，而這些文件描述符其中的任意一個進入讀就緒狀態，select()函數就能夠返回。

select/epoll的優點並非對於單個鏈接能處理得更快，而是在於能處理更多的鏈接。

3.4I/O模型總結

正經的描述都在上面給出了，不知道你們理解了沒有。下面我舉幾個例子總結一下這三種模型：

阻塞I/O：

  • Java3y跟女友去買喜茶，排了好久的隊終於能夠點飲料了。我要綠研，謝謝。但是喜茶不是點了單就能當即拿，因而我在喜茶門口等了一小時纔拿到綠研。
    • 在門口乾等一小時

非阻塞I/O：

  • Java3y跟女友去買一點點，排了好久的隊終於能夠點飲料了。我要波霸奶茶，謝謝。但是一點點不是點了單就能當即拿，同時服務員告訴我：你大概要等半小時哦。大家先去逛逛吧~因而Java3y跟女友去玩了幾把鬥地主，感受時間差很少了。因而又去一點點問：請問到我了嗎？個人單號是xxx。服務員告訴Java3y：還沒到呢，如今的單號是XXX，你還要等一會，能夠去附近耍耍。問了好幾回後，終於拿到個人波霸奶茶了。
    • 去逛了下街、鬥了下地主，時不時問問到我了沒有

I/O複用模型：

  • Java3y跟女友去麥當勞吃漢堡包，如今就厲害了可使用微信小程序點餐了。因而跟女友找了個地方坐下就用小程序點餐了。點餐了以後玩玩鬥地主、聊聊天什麼的。時不時聽到廣播在複述XXX請取餐，反正個人單號還沒到，就繼續玩唄。~~等聽到廣播的時候再取餐就是了。時間過得挺快的，此時傳來：Java3y請過來取餐。因而我就能拿到個人麥辣雞翅漢堡了。
    • 聽廣播取餐，廣播不是爲我一我的服務。廣播喊到我了，我過去取就Ok了。

4、使用NIO完成網絡通訊

4.1NIO基礎繼續講解

回到咱們最開始的圖：

NIO被叫爲 no-blocking io，實際上是在網絡這個層次中理解的，對於FileChannel來講同樣是阻塞。

咱們前面也僅僅講解了FileChannel，對於咱們網絡通訊是還有幾個Channel的~

因此說：咱們一般使用NIO是在網絡中使用的，網上大部分討論NIO都是在網絡通訊的基礎之上的！說NIO是非阻塞的NIO也是網絡中體現的！

從上面的圖咱們能夠發現還有一個Selector選擇器這麼一個東東。從一開始咱們就說過了，nio的核心要素有：

  • Buffer緩衝區
  • Channel通道
  • Selector選擇器

咱們在網絡中使用NIO每每是I/O模型的多路複用模型！

  • Selector選擇器就能夠比喻成麥當勞的廣播。
  • 一個線程可以管理多個Channel的狀態

4.2NIO阻塞形態

爲了更好地理解，咱們先來寫一下NIO在網絡中是阻塞的狀態代碼，隨後看看非阻塞是怎麼寫的就更容易理解了。

  • 是阻塞的就沒有Selector選擇器了，就直接使用Channel和Buffer就完事了。

客戶端：

public class BlockClient {

    public static void main(String[] args) throws IOException {

        // 1. 獲取通道
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 6666));

        // 2. 發送一張圖片給服務端吧
        FileChannel fileChannel = FileChannel.open(Paths.get("X:\\Users\\ozc\\Desktop\\新建文件夾\\1.png"), StandardOpenOption.READ);

        // 3.要使用NIO，有了Channel，就必然要有Buffer，Buffer是與數據打交道的呢
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 4.讀取本地文件(圖片)，發送到服務器
        while (fileChannel.read(buffer) != -1) {

            // 在讀以前都要切換成讀模式
            buffer.flip();

            socketChannel.write(buffer);

            // 讀完切換成寫模式，能讓管道繼續讀取文件的數據
            buffer.clear();
        }

        // 5. 關閉流
        fileChannel.close();
        socketChannel.close();
    }
}

服務端：

public class BlockServer {

    public static void main(String[] args) throws IOException {

        // 1.獲取通道
        ServerSocketChannel server = ServerSocketChannel.open();

        // 2.獲得文件通道，將客戶端傳遞過來的圖片寫到本地項目下(寫模式、沒有則建立)
        FileChannel outChannel = FileChannel.open(Paths.get("2.png"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

        // 3. 綁定連接
        server.bind(new InetSocketAddress(6666));

        // 4. 獲取客戶端的鏈接(阻塞的)
        SocketChannel client = server.accept();

        // 5. 要使用NIO，有了Channel，就必然要有Buffer，Buffer是與數據打交道的呢
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 6.將客戶端傳遞過來的圖片保存在本地中
        while (client.read(buffer) != -1) {

            // 在讀以前都要切換成讀模式
            buffer.flip();

            outChannel.write(buffer);

            // 讀完切換成寫模式，能讓管道繼續讀取文件的數據
            buffer.clear();

        }

        // 7.關閉通道
        outChannel.close();
        client.close();
        server.close();
    }
}

結果就能夠將客戶端傳遞過來的圖片保存在本地了：

此時服務端保存完圖片想要告訴客戶端已經收到圖片啦：

客戶端接收服務端帶過來的數據：

若是僅僅是上面的代碼是不行的！這個程序會阻塞起來！

  • 由於服務端不知道客戶端還有沒有數據要發過來(與剛開始不同，客戶端發完數據就將流關閉了，服務端能夠知道客戶端沒數據發過來了)，致使服務端一直在讀取客戶端發過來的數據。
  • 進而致使了阻塞！

因而客戶端在寫完數據給服務端時，顯式告訴服務端已經發完數據了！

4.3NIO非阻塞形態

若是使用非阻塞模式的話，那麼咱們就能夠不顯式告訴服務器已經發完數據了。咱們下面來看看怎麼寫：

客戶端：

public class NoBlockClient {

    public static void main(String[] args) throws IOException {

        // 1. 獲取通道
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 6666));

        // 1.1切換成非阻塞模式
        socketChannel.configureBlocking(false);

        // 2. 發送一張圖片給服務端吧
        FileChannel fileChannel = FileChannel.open(Paths.get("X:\\Users\\ozc\\Desktop\\新建文件夾\\1.png"), StandardOpenOption.READ);

        // 3.要使用NIO，有了Channel，就必然要有Buffer，Buffer是與數據打交道的呢
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 4.讀取本地文件(圖片)，發送到服務器
        while (fileChannel.read(buffer) != -1) {

            // 在讀以前都要切換成讀模式
            buffer.flip();

            socketChannel.write(buffer);

            // 讀完切換成寫模式，能讓管道繼續讀取文件的數據
            buffer.clear();
        }

        // 5. 關閉流
        fileChannel.close();
        socketChannel.close();
    }
}

服務端：

public class NoBlockServer {

    public static void main(String[] args) throws IOException {

        // 1.獲取通道
        ServerSocketChannel server = ServerSocketChannel.open();

        // 2.切換成非阻塞模式
        server.configureBlocking(false);

        // 3. 綁定鏈接
        server.bind(new InetSocketAddress(6666));

        // 4. 獲取選擇器
        Selector selector = Selector.open();

        // 4.1將通道註冊到選擇器上，指定接收「監聽通道」事件
        server.register(selector, SelectionKey.OP_ACCEPT);

        // 5. 輪訓地獲取選擇器上已「就緒」的事件--->只要select()>0，說明已就緒
        while (selector.select() > 0) {
            // 6. 獲取當前選擇器全部註冊的「選擇鍵」(已就緒的監聽事件)
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();

            // 7. 獲取已「就緒」的事件，(不一樣的事件作不一樣的事)
            while (iterator.hasNext()) {

                SelectionKey selectionKey = iterator.next();

                // 接收事件就緒
                if (selectionKey.isAcceptable()) {

                    // 8. 獲取客戶端的連接
                    SocketChannel client = server.accept();

                    // 8.1 切換成非阻塞狀態
                    client.configureBlocking(false);

                    // 8.2 註冊到選擇器上-->拿到客戶端的鏈接爲了讀取通道的數據(監聽讀就緒事件)
                    client.register(selector, SelectionKey.OP_READ);

                } else if (selectionKey.isReadable()) { // 讀事件就緒

                    // 9. 獲取當前選擇器讀就緒狀態的通道
                    SocketChannel client = (SocketChannel) selectionKey.channel();

                    // 9.1讀取數據
                    ByteBuffer buffer = ByteBuffer.allocate(1024);

                    // 9.2獲得文件通道，將客戶端傳遞過來的圖片寫到本地項目下(寫模式、沒有則建立)
                    FileChannel outChannel = FileChannel.open(Paths.get("2.png"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

                    while (client.read(buffer) > 0) {
                        // 在讀以前都要切換成讀模式
                        buffer.flip();

                        outChannel.write(buffer);

                        // 讀完切換成寫模式，能讓管道繼續讀取文件的數據
                        buffer.clear();
                    }
                }
                // 10. 取消選擇鍵(已經處理過的事件，就應該取消掉了)
                iterator.remove();
            }
        }

    }
}

仍是剛纔的需求：服務端保存了圖片之後，告訴客戶端已經收到圖片了。

在服務端上只要在後面寫些數據給客戶端就行了：

在客戶端上要想獲取獲得服務端的數據，也須要註冊在register上(監聽讀事件)！

public class NoBlockClient2 {

    public static void main(String[] args) throws IOException {

        // 1. 獲取通道
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 6666));

        // 1.1切換成非阻塞模式
        socketChannel.configureBlocking(false);

        // 1.2獲取選擇器
        Selector selector = Selector.open();

        // 1.3將通道註冊到選擇器中，獲取服務端返回的數據
        socketChannel.register(selector, SelectionKey.OP_READ);

        // 2. 發送一張圖片給服務端吧
        FileChannel fileChannel = FileChannel.open(Paths.get("X:\\Users\\ozc\\Desktop\\新建文件夾\\1.png"), StandardOpenOption.READ);

        // 3.要使用NIO，有了Channel，就必然要有Buffer，Buffer是與數據打交道的呢
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 4.讀取本地文件(圖片)，發送到服務器
        while (fileChannel.read(buffer) != -1) {

            // 在讀以前都要切換成讀模式
            buffer.flip();

            socketChannel.write(buffer);

            // 讀完切換成寫模式，能讓管道繼續讀取文件的數據
            buffer.clear();
        }


        // 5. 輪訓地獲取選擇器上已「就緒」的事件--->只要select()>0，說明已就緒
        while (selector.select() > 0) {
            // 6. 獲取當前選擇器全部註冊的「選擇鍵」(已就緒的監聽事件)
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();

            // 7. 獲取已「就緒」的事件，(不一樣的事件作不一樣的事)
            while (iterator.hasNext()) {

                SelectionKey selectionKey = iterator.next();

                // 8. 讀事件就緒
                if (selectionKey.isReadable()) {

                    // 8.1獲得對應的通道
                    SocketChannel channel = (SocketChannel) selectionKey.channel();

                    ByteBuffer responseBuffer = ByteBuffer.allocate(1024);

                    // 9. 知道服務端要返回響應的數據給客戶端，客戶端在這裏接收
                    int readBytes = channel.read(responseBuffer);

                    if (readBytes > 0) {
                        // 切換讀模式
                        responseBuffer.flip();
                        System.out.println(new String(responseBuffer.array(), 0, readBytes));
                    }
                }

                // 10. 取消選擇鍵(已經處理過的事件，就應該取消掉了)
                iterator.remove();
            }
        }
    }


}

測試結果：

下面就簡單總結一下使用NIO時的要點：

  • 將Socket通道註冊到Selector中，監聽感興趣的事件
  • 當感興趣的時間就緒時，則會進去咱們處理的方法進行處理
  • 每處理完一次就緒事件，刪除該選擇鍵(由於咱們已經處理完了)

4.4管道和DataGramChannel

這裏我就再也不講述了，最難的TCP都講了，UDP就很簡單了。

UDP:

管道：

5、總結

總的來講NIO也是一個比較重要的知識點，由於它是學習netty的基礎~

想以一篇來徹底講解NIO顯然是不可能的啦，想要更加深刻了解NIO能夠往下面的連接繼續學習~

參考資料：

若是文章有錯的地方歡迎指正，你們互相交流。習慣在微信看技術文章，想要獲取更多的Java資源的同窗，能夠關注微信公衆號:Java3y。爲了你們方便，剛新建了一下qq羣：742919422，你們也能夠去交流交流。謝謝支持了！但願能多介紹給其餘有須要的朋友

文章的目錄導航：

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程