Java中IO,BIO,NIO,AIO

轉載自：

https://blog.csdn.net/huangwenyi1010/article/details/75577091

提出問題

Java之IO,BIO,NIO,AIO知多少？？？

---

解決問題

前言

本篇文章參考了網上很多大神的文章，包括一些代碼實例。在文章最後都有寫明出處。如果文章有寫錯的地方，歡迎留下評論。本篇文章是我錄製視頻《Java之IO,BIO,NIO,AIO知多少？》的講課稿子。下面是視頻地址，歡迎購買觀看：

http://edu.csdn.net/lecturer/lecturer_detail?lecturer_id=994

IO基礎知識回顧

java的核心庫java.io提供了全面的IO接口。包括：文件讀寫、標準設備輸出等。Java中IO是以流爲基礎進行輸入輸出的，所有數據被串行化寫入輸出流，或者從輸入流讀入。

java.nio（java non-blocking IO），nio 是non-blocking的簡稱，是jdk1.4 及以上版本里提供的新api（New IO） ，爲所有的原始類型（boolean類型除外）提供緩存支持。Sun 官方標榜的特性如下： 爲所有的原始類型提供(Buffer)緩存支持。字符集編碼解碼解決方案。 Channel ：一個新的原始I/O 抽象。 支持鎖和內存映射文件的文件訪問接口。 提供多路(non-bloking) 非阻塞式的高伸縮性網絡I/O 。

IO流類圖結構

IO流簡單例子

實例一：

FileInputStream fis=null;
FileOutputStream fos=null;
try {
    fis = new FileInputStream(new File("D:\\a.txt"));
    fos = new FileOutputStream(new File("D:\\y.txt"));
    int ch;
    while((ch=fis.read()) != -1){
        System.out.println((char)ch);
        fos.write(ch);
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}finally {
    if(null != fos){
        fos.close();
    }
    if(null != fis){
        fis.close();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

實例二：字節流轉換成字符流

public static void main(String[] args) throws Exception{
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\a.txt")));
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\y.txt")));
            String s;
            StringBuilder sb = new StringBuilder();
            while((s=br.readLine())!=null){
                System.out.println(s);
                bw.write(s);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(null != bw){
                bw.close();
            }
            if(null != br){
                br.close();
            }
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

實例三：用轉換流從控制檯上讀入數據

public static void main(String[] args) throws Exception{
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            String s=br.readLine();
            System.out.println(s);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(null != br){
                br.close();
            }
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

BIO編程

傳統BIO通信模型圖

​ 傳統的同步阻塞模型開發中，ServerSocket負責綁定IP地址，啓動監聽端口；Socket負責發起連接操作。連接成功後，雙方通過輸入和輸出流進行同步阻塞式通信。 服務端提供IP和監聽端口，客戶端通過連接操作想服務端監聽的地址發起連接請求，通過三次握手連接，如果連接成功建立，雙方就可以通過套接字進行通信。

​ 簡單的描述一下BIO的服務端通信模型：採用BIO通信模型的服務端，通常由一個獨立的Acceptor線程負責監聽客戶端的連接，它接收到客戶端連接請求之後爲每個客戶端創建一個新的線程進行鏈路處理沒處理完成後，通過輸出流返回應答給客戶端，線程銷燬。即典型的一請求一應答通宵模型。

​ 傳統BIO通信模型圖：

​

​ 該模型最大的問題就是缺乏彈性伸縮能力，當客戶端併發訪問量增加後，服務端的線程個數和客戶端併發訪問數呈1:1的正比關係，Java中的線程也是比較寶貴的系統資源，線程數量快速膨脹後，系統的性能將急劇下降，隨着訪問量的繼續增大，系統最終就死-掉-了。

傳統BIO編程實例

傳統的同步阻塞模型開發中，ServerSocket負責綁定IP地址，啓動監聽端口；Socket負責發起連接操作。連接成功後，雙方通過輸入和輸出流進行同步阻塞式通信。

package com.evada.de;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;

/**
 * 描述：傳統BIO編程實例
 * @author Ay
 * @date 2017/6/27
 */
public final class AyTest extends BaseTest {

    public static void main(String[] args) throws InterruptedException {
        //啓動線程，運行服務器
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    ServerBetter.start();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        //避免客戶端先於服務器啓動前執行代碼
        Thread.sleep(100);

        //啓動線程，運行客戶端
        char operators[] = {'+', '-', '*', '/'};
        Random random = new Random(System.currentTimeMillis());
        new Thread(new Runnable() {
            @SuppressWarnings("static-access")
            @Override
            public void run() {
                while (true) {
                    //隨機產生算術表達式
                    String expression = random.nextInt(10) + "" + operators[random.nextInt(4)] + (random.nextInt(10) + 1);
                    Client.send(expression);
                    try {
                        Thread.currentThread().sleep(random.nextInt(1000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

}

class ServerBetter{

    //默認的端口號
    private static int DEFAULT_PORT = 12345;
    //單例的ServerSocket
    private static ServerSocket server;

    //根據傳入參數設置監聽端口，如果沒有參數調用以下方法並使用默認值
    public static void start() throws IOException {
        //使用默認值端口
        start(DEFAULT_PORT);
    }
    //這個方法不會被大量併發訪問，不太需要考慮效率，直接進行方法同步就行了
    public synchronized static void start(int port) throws IOException{
        if(server != null) return;
        try{
            //通過構造函數創建ServerSocket，如果端口合法且空閒，服務端就監聽成功
            server = new ServerSocket(port);
            System.out.println("服務器已啓動，端口號：" + port);
            //通過無線循環監聽客戶端連接，如果沒有客戶端接入，將阻塞在accept操作上。
            while(true){
                Socket socket = server.accept();
                //當有新的客戶端接入時，會執行下面的代碼
                //然後創建一個新的線程處理這條Socket鏈路
                new Thread(new ServerHandler(socket)).start();
            }
        }finally{
            //一些必要的清理工作
            if(server != null){
                System.out.println("服務器已關閉。");
                server.close();
                server = null;
            }
        }
    }

}


class ServerHandler implements Runnable{
    private Socket socket;
    public ServerHandler(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        BufferedReader in = null;
        PrintWriter out = null;
        try{
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(),true);
            String expression;
            String result;
            while(true){
                //通過BufferedReader讀取一行
                //如果已經讀到輸入流尾部，返回null,退出循環
                //如果得到非空值，就嘗試計算結果並返回
                if((expression = in.readLine())==null) break;
                System.out.println("服務器收到消息：" + expression);
                try{
                    result = "123";//Calculator.cal(expression).toString();
                }catch(Exception e){
                    result = "計算錯誤：" + e.getMessage();
                }
                out.println(result);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //一些必要的清理工作
            if(in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                in = null;
            }
            if(out != null){
                out.close();
                out = null;
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                socket = null;
            }
        }
    }
}

class Client {
    //默認的端口號
    private static int DEFAULT_SERVER_PORT = 12345;
    //默認服務器Ip
    private static String DEFAULT_SERVER_IP = "127.0.0.1";

    public static void send(String expression){
        send(DEFAULT_SERVER_PORT,expression);
    }
    public static void send(int port,String expression){
        System.out.println("算術表達式爲：" + expression);
        Socket socket = null;
        BufferedReader in = null;
        PrintWriter out = null;
        try{
            socket = new Socket(DEFAULT_SERVER_IP,port);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(),true);
            out.println(expression);
            System.out.println("___結果爲：" + in.readLine());
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //一下必要的清理工作
            if(in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                in = null;
            }
            if(out != null){
                out.close();
                out = null;
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                socket = null;
            }
        }
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130
• 131
• 132
• 133
• 134
• 135
• 136
• 137
• 138
• 139
• 140
• 141
• 142
• 143
• 144
• 145
• 146
• 147
• 148
• 149
• 150
• 151
• 152
• 153
• 154
• 155
• 156
• 157
• 158
• 159
• 160
• 161
• 162
• 163
• 164
• 165
• 166
• 167
• 168
• 169
• 170
• 171
• 172
• 173
• 174
• 175
• 176
• 177
• 178
• 179
• 180
• 181
• 182
• 183
• 184
• 185
• 186
• 187
• 188
• 189
• 190
• 191
• 192
• 193

僞異步I/O編程

我們可以使用線程池來管理這些線程（需要了解更多請參考前面提供的文章），實現1個或多個線程處理N個客戶端的模型（但是底層還是使用的同步阻塞I/O），通常被稱爲“僞異步I/O模型“

僞異步I/O編程模型圖

測試運行結果是一樣的。

​ 我們知道，如果使用CachedThreadPool線程池（不限制線程數量，如果不清楚請參考文首提供的文章），其實除了能自動幫我們管理線程（複用），看起來也就像是1:1的客戶端：線程數模型，而使用FixedThreadPool我們就有效的控制了線程的最大數量，保證了系統有限的資源的控制，實現了N:M的僞異步I/O模型。

​ 但是，正因爲限制了線程數量，如果發生大量併發請求，超過最大數量的線程就只能等待，直到線程池中的有空閒的線程可以被複用。而對Socket的輸入流就行讀取時，會一直阻塞，直到發生：

• ​ 有數據可讀
• ​ 可用數據以及讀取完畢
• ​ 發生空指針或I/O異常

​ 所以在讀取數據較慢時（比如數據量大、網絡傳輸慢等），大量併發的情況下，其他接入的消息，只能一直等待，這就是最大的弊端。

​ 而後面即將介紹的NIO，就能解決這個難題。

僞異步IO編程代碼

package com.anxpp.io.calculator.bio;  
import java.io.IOException;  
import java.net.ServerSocket;  
import java.net.Socket;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
/** 
 * BIO服務端源碼__僞異步I/O 
 * @author yangtao__anxpp.com 
 * @version 1.0 
 */  
public final class ServerBetter {  
    //默認的端口號  
    private static int DEFAULT_PORT = 12345;  
    //單例的ServerSocket  
    private static ServerSocket server;  
    //線程池 懶漢式的單例  
    private static ExecutorService executorService = Executors.newFixedThreadPool(60);  
    //根據傳入參數設置監聽端口，如果沒有參數調用以下方法並使用默認值  
    public static void start() throws IOException{  
        //使用默認值  
        start(DEFAULT_PORT);  
    }  
    //這個方法不會被大量併發訪問，不太需要考慮效率，直接進行方法同步就行了  
    public synchronized static void start(int port) throws IOException{  
        if(server != null) return;  
        try{  
            //通過構造函數創建ServerSocket  
            //如果端口合法且空閒，服務端就監聽成功  
            server = new ServerSocket(port);  
            System.out.println("服務器已啓動，端口號：" + port);  
            //通過無線循環監聽客戶端連接  
            //如果沒有客戶端接入，將阻塞在accept操作上。  
            while(true){  
                Socket socket = server.accept();  
                //當有新的客戶端接入時，會執行下面的代碼  
                //然後創建一個新的線程處理這條Socket鏈路  
                executorService.execute(new ServerHandler(socket));  
            }  
        }finally{  
            //一些必要的清理工作  
            if(server != null){  
                System.out.println("服務器已關閉。");  
                server.close();  
                server = null;  
            }  
        }  
    }  
}  

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49

• 1,同步和異步是針對應用程序和內核的交互而言的。
• 2,阻塞和非阻塞是針對於進程在訪問數據的時候，根據IO操作的就緒狀態來採取的不同方式，說白了是一種讀取或者寫入操作函數的實現方式，阻塞方式下讀取或者寫入函數將一直等待，而非阻塞方式下，讀取或者寫入函數會立即返回一個狀態值。

由上描述基本可以總結一句簡短的話，同步和異步是目的，阻塞和非阻塞是實現方式。

同步阻塞：
在此種方式下，用戶進程在發起一個IO操作以後，必須等待IO操作的完成，只有當真正完成了IO操作以後，用戶進程才能運行。JAVA傳統的IO模型屬於此種方式。

同步非阻塞：
在此種方式下，用戶進程發起一個IO操作以後邊可返回做其它事情，但是用戶進程需要時不時的詢問IO操作是否就緒，這就要求用戶進程不停的去詢問，從而引入不必要的CPU資源浪費。其中目前JAVA的NIO就屬於同步非阻塞IO。
異步：
此種方式下是指應用發起一個IO操作以後，不等待內核IO操作的完成，等內核完成IO操作以後會通知應用程序。

如果你想吃一份宮保雞丁蓋飯：

同步阻塞：你到飯館點餐，然後在那等着，還要一邊喊：好了沒啊！

同步非阻塞：在飯館點完餐，就去遛狗了。不過溜一會兒，就回飯館喊一聲：好了沒啊！

異步阻塞：遛狗的時候，接到飯館電話，說飯做好了，讓您親自去拿。

異步非阻塞：飯館打電話說，我們知道您的位置，一會給你送過來，安心遛狗就可以了。

NIO 編程

簡介

Java NIO(New IO)是一個可以替代標準Java IO API（從Java 1.4開始)，Java NIO提供了與標準IO不同的IO工作方式。

Java NIO 由以下幾個核心部分組成：

• Channels
• Buffers
• Selectors

雖然Java NIO 中除此之外還有很多類和組件，但Channel，Buffer 和 Selector 構成了核心的API。其它組件，如Pipe和FileLock，只不過是與三個核心組件共同使用的工具類。因此，我將集中精力在這三個組件上。其它組件會在單獨的章節中講到。

注意（每個線程的處理流程大概都是讀取數據、解碼、計算處理、編碼、發送響應）

非常形象的實例

小量的線程如何同時爲大量連接服務呢，答案就是就緒選擇。這就好比到餐廳吃飯，每來一桌客人，都有一個服務員專門爲你服務，從你到餐廳到結帳走人，這樣方式的好處是服務質量好，一對一的服務，VIP啊，可是缺點也很明顯，成本高，如果餐廳生意好，同時來100桌客人，就需要100個服務員，那老闆發工資的時候得心痛死了，這就是傳統的一個連接一個線程的方式。

老闆是什麼人啊，精着呢。這老闆就得捉摸怎麼能用10個服務員同時爲100桌客人服務呢，老闆就發現，服務員在爲客人服務的過程中並不是一直都忙着，客人點完菜，上完菜，吃着的這段時間，服務員就閒下來了，可是這個服務員還是被這桌客人佔用着，不能爲別的客人服務，用華爲領導的話說，就是工作不飽滿。那怎麼把這段閒着的時間利用起來呢。這餐廳老闆就想了一個辦法，讓一個服務員（前臺）專門負責收集客人的需求，登記下來，比如有客人進來了、客人點菜了，客人要結帳了，都先記錄下來按順序排好。每個服務員到這裏領一個需求，比如點菜，就拿着菜單幫客人點菜去了。點好菜以後，服務員馬上回來，領取下一個需求，繼續爲別人客人服務去了。這種方式服務質量就不如一對一的服務了，當客人數據很多的時候可能需要等待。但好處也很明顯，由於在客人正吃飯着的時候服務員不用閒着了，服務員這個時間內可以爲其他客人服務了，原來10個服務員最多同時爲10桌客人服務，現在可能爲50桌，10客人服務了。

這種服務方式跟傳統的區別有兩個：

1、增加了一個角色，要有一個專門負責收集客人需求的人。NIO裏對應的就是Selector。

2、由阻塞服務方式改爲非阻塞服務了，客人吃着的時候服務員不用一直侯在客人旁邊了。傳統的IO操作，比如read()，當沒有數據可讀的時候，線程一直阻塞被佔用，直到數據到來。NIO中沒有數據可讀時，read()會立即返回0，線程不會阻塞。

NIO中，客戶端創建一個連接後，先要將連接註冊到Selector，相當於客人進入餐廳後，告訴前臺你要用餐，前臺會告訴你你的桌號是幾號，然後你就可能到那張桌子坐下了，SelectionKey就是桌號。當某一桌需要服務時，前臺就記錄哪一桌需要什麼服務，比如1號桌要點菜，2號桌要結帳，服務員從前臺取一條記錄，根據記錄提供服務，完了再來取下一條。這樣服務的時間就被最有效的利用起來了。

工作原理

Java NIO和IO的主要區別

IO	NIO
Stream oriented	Buffer oriented
Blocking IO	Non blocking IO
	Selectors

面向流與面向緩衝

Java NIO和IO之間第一個最大的區別是，IO是面向流的，NIO是面向緩衝區的

Java IO面向流意味着每次從流中讀一個或多個字節，直至讀取所有字節，它們沒有被緩存在任何地方。此外，它不能前後移動流中的數據。如果需要前後移動從流中讀取的數據，需要先將它緩存到一個緩衝區。 Java NIO的緩衝導向方法略有不同。數據讀取到一個它稍後處理的緩衝區，需要時可在緩衝區中前後移動。這就增加了處理過程中的靈活性。但是，還需要檢查是否該緩衝區中包含所有您需要處理的數據。而且，需確保當更多的數據讀入緩衝區時，不要覆蓋緩衝區裏尚未處理的數據。

阻塞與非阻塞IO

Java IO的各種流是阻塞的。這意味着，當一個線程調用read() 或 write()時，該線程被阻塞，直到有一些數據被讀取，或數據完全寫入。該線程在此期間不能再幹任何事情了。 Java NIO的非阻塞模式，使一個線程從某通道發送請求讀取數據，但是它僅能得到目前可用的數據，如果目前沒有數據可用時，就什麼都不會獲取。而不是保持線程阻塞，所以直至數據變的可以讀取之前，該線程可以繼續做其他的事情。 非阻塞寫也是如此。一個線程請求寫入一些數據到某通道，但不需要等待它完全寫入，這個線程同時可以去做別的事情。 線程通常將非阻塞IO的空閒時間用於在其它通道上執行IO操作，所以一個單獨的線程現在可以管理多個輸入和輸出通道（channel）。

NIO和IO如何影響應用程序的設計

無論您選擇IO或NIO工具箱，可能會影響您應用程序設計的以下幾個方面：

• 對NIO或IO類的API調用。
• 數據處理。
• 用來處理數據的線程數。

通道 Channel

簡介

Channel 是對數據的源頭和數據目標點流經途徑的抽象，在這個意義上和 InputStream 和 OutputStream 類似。Channel可以譯爲“通道、管 道”，而傳輸中的數據彷彿就像是在其中流淌的水。前面也提到了Buffer，Buffer和Channel相互配合使用，纔是Java的NIO。

Java NIO的通道與流區別

• 既可以從通道中讀取數據，又可以寫數據到通道。但流的讀寫通常是單向的。

• 通道可以異步地讀寫。

• 通道中的數據總是要先讀到一個Buffer，或者總是要從一個Buffer中寫入。

​

我們對數據的讀取和寫入要通過Channel，它就像水管一樣，是一個通道。通道不同於流的地方就是通道是雙向的，可以用於讀、寫和同時讀寫操作。 數據可以從Channel讀到Buffer中，也可以從Buffer 寫到Channel中。

注意：通道必須結合Buffer使用，不能直接向通道中讀/寫數據

Channel主要分類

廣義上來說通道可以被分爲兩類：File I/O和Stream I/O，也就是文件通道和套接字通道。如果分的更細緻一點則是：

• FileChannel 從文件讀寫數據
• SocketChannel 通過TCP讀寫網絡數據
• ServerSocketChannel 可以監聽新進來的TCP連接，並對每個鏈接創建對應的SocketChannel
• DatagramChannel 通過UDP讀寫網絡中的數據
• Pipe

Channel的實現

這些是Java NIO中最重要的通道的實現：

• FileChannel：從文件中讀寫數據。
• DatagramChannel：能通過UDP讀寫網絡中的數據。
• SocketChannel：能通過TCP讀寫網絡中的數據。
• ServerSocketChannel：可以監聽新進來的TCP連接，像Web服務器那樣。對每一個新進來的連接都會創建一個SocketChannel。

打開FileChannel

在使用FileChannel之前，必須先打開它。但是，我們無法直接打開一個FileChannel，需要通過使用一個InputStream、OutputStream或RandomAccessFile來獲取一個FileChannel實例。下面是通過RandomAccessFile打開FileChannel的示例：

RandomAccessFile aFile = new RandomAccessFile("d://nio-data.txt", "rw");
FileChannel inChannel = aFile.getChannel();

• 1
• 2

從FileChannel讀取數據

調用多個read()方法之一從FileChannel中讀取數據。如：

ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buf);

• 1
• 2

首先，分配一個Buffer。從FileChannel中讀取的數據將被讀到Buffer中。

然後，調用FileChannel.read()方法。該方法將數據從FileChannel讀取到Buffer中。read()方法返回的int值表示了有多少字節被讀到了Buffer中。如果返回-1，表示到了文件末尾。

向FileChannel寫數據

使用FileChannel.write()方法向FileChannel寫數據，該方法的參數是一個Buffer。如：

String newData = "New String to write to file..." + System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
    channel.write(buf);
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

注意FileChannel.write()是在while循環中調用的。因爲無法保證write()方法一次能向FileChannel寫入多少字節，因此需要重複調用write()方法，直到Buffer中已經沒有尚未寫入通道的字節。

關閉FileChannel

用完FileChannel後必須將其關閉。如：

channel.close();

• 1

FileChannel的position方法

有時可能需要在FileChannel的某個特定位置進行數據的讀/寫操作。可以通過調用position()方法獲取FileChannel的當前位置。

也可以通過調用position(long pos)方法設置FileChannel的當前位置。

這裏有兩個例子:

long pos = channel.position();
channel.position(pos +123);

• 1
• 2

如果將位置設置在文件結束符之後，然後試圖從文件通道中讀取數據，讀方法將返回-1 —— 文件結束標誌。

如果將位置設置在文件結束符之後，然後向通道中寫數據，文件將撐大到當前位置並寫入數據。這可能導致“文件空洞”，磁盤上物理文件中寫入的數據間有空隙。

FileChannel的size方法

FileChannel實例的size()方法將返回該實例所關聯文件的大小。如:

long fileSize = channel.size();

• 1

FileChannel的truncate方法

可以使用FileChannel.truncate()方法截取一個文件。截取文件時，文件將中指定長度後面的部分將被刪除。如：

channel.truncate(1024);

• 1

這個例子截取文件的前1024個字節。

FileChannel的force方法

FileChannel.force()方法將通道里尚未寫入磁盤的數據強制寫到磁盤上。出於性能方面的考慮，操作系統會將數據緩存在內存中，所以無法保證寫入到FileChannel裏的數據一定會即時寫到磁盤上。要保證這一點，需要調用force()方法。

force()方法有一個boolean類型的參數，指明是否同時將文件元數據（權限信息等）寫到磁盤上。

下面的例子同時將文件數據和元數據強制寫到磁盤上：

channel.force(true);

• 1

transferFrom()

FileChannel無法設置爲非阻塞模式，它總是運行在阻塞模式下。

FileChannel的transferFrom()方法可以將數據從源通道傳輸到FileChannel中（譯者注：這個方法在JDK文檔中的解釋爲將字節從給定的可讀取字節通道傳輸到此通道的文件中）。下面是一個簡單的例子：

//在使用FileChannel之前，必須先打開它。但是，我們無法直接打開一個FileChannel，
//需要通過使用一個InputStream、OutputStream或RandomAccessFile來獲取一個FileChannel實例。
RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");  
FileChannel      fromChannel = fromFile.getChannel();  
RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");  
FileChannel      toChannel = toFile.getChannel();   
long position = 0;  
long count = fromChannel.size();  
toChannel.transferFrom(position, count, fromChannel);  

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

transferFrom 方法的輸入參數 position 表示從 position 處開始向目標文件寫入數據，count 表示最多傳輸的字節數。如果源通道的剩餘空間小於 count 個字節，則所傳輸的字節數要小於請求的字節數。

此外要注意，在 SoketChannel 的實現中，SocketChannel 只會傳輸此刻準備好的數據（可能不足count字節）。因此，SocketChannel 可能不會將請求的所有數據(count個字節)全部傳輸到 FileChannel 中。

transferTo()

transferTo()方法將數據從FileChannel傳輸到其他的channel中。下面是一個簡單的例子：

RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");  
FileChannel      fromChannel = fromFile.getChannel();    
RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");  
FileChannel      toChannel = toFile.getChannel();  
long position = 0;  
long count = fromChannel.size();  
fromChannel.transferTo(position, count, toChannel);  

• 1
• 2
• 3
• 4
• 5
• 6
• 7

是不是發現這個例子和前面那個例子特別相似？除了調用方法的FileChannel對象不一樣外，其他的都一樣。

上面所說的關於SocketChannel的問題在transferTo()方法中同樣存在。SocketChannel會一直傳輸數據直到目標buffer被填滿。

Channel簡單實例

下面是Channel的一個簡單的實例：

程序清單 1-1
RandomAccessFile aFile = new RandomAccessFile("d:\\ay.txt", "rw");
FileChannel fileChannel = aFile.getChannel();
//分配緩存區大小
ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = fileChannel.read(buf);
while (bytesRead != -1) {
    System.out.println("Read " + bytesRead);
    //buf.flip()的調用，首先讀取數據到Buffer，然後反轉Buffer,接着再從Buffer中讀取數據（注：flip：空翻，反轉）
    buf.flip();
    //判斷是否有剩餘（注：Remaining：剩餘的）
    while(buf.hasRemaining()){
        System.out.print((char) buf.get());
    }
    buf.clear();
    bytesRead = fileChannel.read(buf);
}
aFile.close();

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

緩衝區 Buffer

緩衝區本質上是一塊可以寫入數據，然後可以從中讀取數據的內存。這塊內存被包裝成NIO Buffer對象，並提供了一組方法，用來方便的訪問該塊內存。

Buffer的基本用法

使用Buffer讀寫數據一般遵循以下四個步驟：

• 寫入數據到Buffer
• 調用flip()方法
• 從Buffer中讀取數據
• 調用clear()方法或者compact()方法

當向buffer寫入數據時，buffer會記錄下寫了多少數據。一旦要讀取數據，需要通過 flip() 方法將 Buffer 從寫模式切換到讀模式。在讀模式下，可以讀取之前寫入到buffer的所有數據。

一旦讀完了所有的數據，就需要清空緩衝區，讓它可以再次被寫入。有兩種方式能清空緩衝區：調用 clear() 或 compact() 方法。clear() 方法會清空整個緩衝區。compact() 方法只會清除已經讀過的數據。任何未讀的數據都被移到緩衝區的起始處，新寫入的數據將放到緩衝區未讀數據的後面。

程序清單 1-1
RandomAccessFile aFile = new RandomAccessFile("d:\\ay.txt", "rw");
FileChannel fileChannel = aFile.getChannel();
//分配緩存區大小
ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = fileChannel.read(buf);
while (bytesRead != -1) {
    System.out.println("Read " + bytesRead);
    //buf.flip()的調用，首先讀取數據到Buffer，然後反轉Buffer,接着再從Buffer中讀取數據（注：flip：空翻，反轉）
    buf.flip();
    //判斷是否有剩餘（注：Remaining：剩餘的）
    while(buf.hasRemaining()){
        System.out.print((char) buf.get());
    }
    buf.clear();
    bytesRead = fileChannel.read(buf);
}
aFile.close();

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

Buffer的三個屬性

爲了理解Buffer的工作原理，需要熟悉它的三個屬性：

• capacity：作爲一個內存塊，Buffer 有一個固定的大小值，也叫 “capacity”. 你只能往裏寫 capacity 個 byte、long，char 等類型。一旦 Buffer 滿了，需要將其清空（通過讀數據或者清除數據）才能繼續寫數據往裏寫數據。
• position：當你寫數據到Buffer中時，position表示當前的位置。初始的position值爲0.當一個byte、long等數據寫到Buffer後， position會向前移動到下一個可插入數據的 Buffer 單元。position 最大可爲 capacity – 1。 當讀取數據時，也是從某個特定位置讀。當將 Buffer 從寫模式切換到讀模式，position會被重置爲 0。當從Buffer的 position 處讀取數據時，position 向前移動到下一個可讀的位置。
• limit：在寫模式下，Buffer的limit表示你最多能往 Buffer 裏寫多少數據。 寫模式下，limit 等於 Buffer 的 capacity 。 當切換Buffer到讀模式時， limit 表示你最多能讀到多少數據。因此，當切換Buffer到讀模式時，limit 會被設置成寫模式下的 position 值。換句話說，你能讀到之前寫入的所有數據（limit被設置成已寫數據的數量，這個值在寫模式下就是 position ）。

Buffer的類型

Java NIO 有以下Buffer類型：

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

Buffer的分配

要想獲得一個Buffer對象首先要進行分配。 每一個Buffer類都有一個allocate方法。下面是一個分配48字節capacity的ByteBuffer的例子。

ByteBuffer buf = ByteBuffer.allocate(48);  

• 1

這是分配一個可存儲1024個字符的CharBuffer：

CharBuffer buf = CharBuffer.allocate(1024);  

• 1

Buffer寫數據

寫數據到Buffer有兩種方式：

• 從Channel寫到Buffer。
• 通過Buffer的put()方法寫到Buffer裏。

從Channel寫到Buffer，例如：

int bytesRead = inChannel.read(buf); //read into buffer

• 1

通過put方法寫Buffer的例子：

buf.put(127);  

• 1

put方法有很多版本，允許你以不同的方式把數據寫入到Buffer中。例如， 寫到一個指定的位置，或者把一個字節數組寫入到Buffer。 更多Buffer實現的細節參考JavaDoc。

flip()方法

flip方法將Buffer從寫模式切換到讀模式。調用flip()方法會將position設回0，並將limit設置成之前position的值。

換句話說，position現在用於標記讀的位置，limit表示之前寫進了多少個byte、char等 —— 現在能讀取多少個byte、char等。

Buffer中讀取數據

從Buffer中讀取數據有兩種方式：

• 從Buffer讀取數據到Channel。
• 使用get()方法從Buffer中讀取數據。

從Buffer讀取數據到Channel的例子：

//read from buffer into channel.  
int bytesWritten = inChannel.write(buf);  

• 1
• 2

使用get()方法從Buffer中讀取數據的例子 ：

byte aByte = buf.get();  

• 1

get方法有很多版本，允許你以不同的方式從Buffer中讀取數據。例如，從指定position讀取，或者從Buffer中讀取數據到字節數組。

rewind()方法

Buffer.rewind()將 position 設回0，所以你可以重讀Buffer中的所有數據。limit 保持不變，仍然表示能從Buffer中讀取多少個元素（byte、char等）

clear()與compact()方法

一旦讀完Buffer中的數據，需要讓Buffer準備好再次被寫入。可以通過clear()或compact()方法來完成。

如果調用的是 clear() 方法，position將被設回 0，limit被設置成 capacity 的值。換句話說，Buffer 被清空了。

如果Buffer中有一些未讀的數據，調用clear()方法，數據將“被遺忘”，意味着不再有任何標記會告訴你哪些數據被讀過，哪些還沒有。

如果Buffer中仍有未讀的數據，且後續還需要這些數據，但是此時想要先先寫些數據，那麼使用compact()方法。

compact()方法將所有未讀的數據拷貝到Buffer起始處。然後將position設到最後一個未讀元素正後面。limit 屬性依然像 clear() 方法一樣，設置成 capacity。現在Buffer準備好寫數據了，但是不會覆蓋未讀的數據。

mark()與reset()方法

通過調用Buffer.mark()方法，可以標記Buffer中的一個特定position。之後可以通過調用Buffer.reset()方法恢復到這個position。例如：

buffer.mark();  
//set position back to mark.  
buffer.reset();  
equals()與compareTo()方法

• 1
• 2
• 3
• 4

可以使用equals()和compareTo()方法兩個Buffer。

equals()

當滿足下列條件時，表示兩個Buffer相等：

• 有相同的類型（byte、char、int等）。
• Buffer中剩餘的 byte、char 等的個數相等。
• Buffer中所有剩餘的byte、char等都相同。

如你所見，equals只是比較Buffer的一部分，不是每一個在它裏面的元素都比較。實際上，它只比較Buffer中的剩餘元素。

compareTo()方法

compareTo()方法比較兩個Buffer的剩餘元素(byte、char等)， 如果滿足下列條件，則認爲一個Buffer “小於” 另一個Buffer：

• 第一個不相等的元素小於另一個Buffer中對應的元素。
• 所有元素都相等，但第一個Buffer比另一個先耗盡(第一個Buffer的元素個數比另一個少)。

選擇器（ Selector）

簡單介紹

Java NIO引入了選擇器的概念，選擇器用於監聽多個通道的事件（比如：連接打開，數據到達）。Selector提供選擇已經就緒的任務的能力：Selector會不斷輪詢註冊在其上的Channel，如果某個Channel上面發生讀或者寫事件，這個Channel就處於就緒狀態，會被Selector輪詢出來，然後通過SelectionKey可以獲取就緒Channel的集合，進行後續的I/O操作。

一個Selector可以同時輪詢多個Channel，因爲JDK使用了epoll()代替傳統的select實現，所以沒有最大連接句柄1024/2048的限制。所以，只需要一個線程負責Selector的輪詢，就可以接入成千上萬的客戶端。

要使用Selector，得向 Selector 註冊 Channel ，然後調用它的 select() 方法。這個方法會一直阻塞到某個註冊的通道有事件就緒。一旦這個方法返回，線程就可以處理這些事件，事件的例子比如新連接進來，數據接收等。

Selector的創建

通過調用Selector.open()方法創建一個Selector，如下：

Selector selector = Selector.open();  

• 1

Selector註冊通道

爲了將 Channel 和 Selector 配合使用，必須將 channel 註冊到 selector 上。通過 SelectableChannel.register() 方法來實現，如下：

channel.configureBlocking(false);  
SelectionKey key = channel.register(selector,  Selectionkey.OP_READ);  

• 1
• 2

與 Selector 一起使用時，Channel 必須處於非阻塞模式下。這意味着不能將 FileChannel 與 Selector 一起使用，因爲 FileChannel 不能切換到非阻塞模式。而套接字通道都可以。

注意register()方法的第二個參數。這是一個“interest集合”，意思是在通過Selector監聽Channel時對什麼事件感興趣。可以監聽四種不同類型的事件：

• Connect
• Accept
• Read
• Write

通道觸發了一個事件意思是該事件已經就緒。所以，某個channel成功連接到另一個服務器稱爲“連接就緒”。一個 server socket channel 準備好接收新進入的連接稱爲“接收就緒”。一個有數據可讀的通道可以說是“讀就緒”。等待寫數據的通道可以說是“寫就緒”。

這四種事件用 SelectionKey 的四個常量來表示：

• SelectionKey.OP_CONNECT
• SelectionKey.OP_ACCEPT
• SelectionKey.OP_READ
• SelectionKey.OP_WRITE

如果你對不止一種事件感興趣，那麼可以用 “ 位 或 ” 操作符將常量連接起來，如下：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;  

• 1

SelectionKey

在上一小節中，當向Selector註冊Channel時，register() 方法會返回一個SelectionKey對象。這個對象包含了一些你感興趣的屬性：

• interest集合
• ready集合
• Channel
• Selector
• 附加的對象（可選）

下面我會描述這些屬性。

interest集合

就像向Selector註冊通道一節中所描述的，interest集合是你所選擇的感興趣的事件集合。可以通過 SelectionKey 讀寫 interest 集合，像這樣：

int interestSet = selectionKey.interestOps();
boolean isInterestedInAccept  = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT；
boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
boolean isInterestedInRead    = interestSet & SelectionKey.OP_READ;
boolean isInterestedInWrite   = interestSet & SelectionKey.OP_WRITE;

• 1
• 2
• 3
• 4
• 5

可以看到，用“位與”操作interest 集合和給定的 SelectionKey 常量，可以確定某個確定的事件是否在 interest 集合中。

ready集合

ready 集合是通道已經準備就緒的操作的集合。在一次選擇(Selection)之後，你會首先訪問這個readySet。Selection將在下一小節進行解釋。可以這樣訪問ready集合：

int readySet = selectionKey.readyOps();

• 1

可以用像檢測 interest 集合那樣的方法，來檢測channel中什麼事件或操作已經就緒。但是，也可以使用以下四個方法，它們都會返回一個布爾類型：

selectionKey.isAcceptable();
selectionKey.isConnectable();
selectionKey.isReadable();
selectionKey.isWritable();

• 1
• 2
• 3
• 4

Channel + Selector

從SelectionKey訪問Channel和Selector很簡單。如下：

Channel  channel  = selectionKey.channel();
Selector selector = selectionKey.selector();

• 1
• 2

附加的對象

可以將一個對象或者更多信息附着到SelectionKey上，這樣就能方便的識別某個給定的通道。例如，可以附加 與通道一起使用的Buffer，或是包含聚集數據的某個對象。使用方法如下：

selectionKey.attach(theObject);
Object attachedObj = selectionKey.attachment();

• 1
• 2

還可以在用register()方法向Selector註冊Channel的時候附加對象。如：

SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

• 1

通過Selector選擇通道

一旦向Selector註冊了一或多個通道，就可以調用幾個重載的select()方法。這些方法返回你所感興趣的事件（如連接、接受、讀或寫）已經準備就緒的那些通道。換句話說，如果你對“讀就緒”的通道感興趣，select()方法會返回讀事件已經就緒的那些通道。

下面是select()方法：

• int select()
• int select(long timeout)
• int selectNow()

select()阻塞到至少有一個通道在你註冊的事件上就緒了。

select(long timeout) 和 select() 一樣，除了最長會阻塞 timeout 毫秒(參數)。

selectNow() 不會阻塞，不管什麼通道就緒都立刻返回（譯者注：此方法執行非阻塞的選擇操作。如果自從前一次選擇操作後，沒有通道變成可選擇的，則此方法直接返回零。）。

select()方法返回的int值表示有多少通道已經就緒。亦即，自上次調用select()方法後有多少通道變成就緒狀態。如果調用select()方法，因爲有一個通道變成就緒狀態，返回了1，若再次調用select()方法，如果另一個通道就緒了，它會再次返回1。如果對第一個就緒的channel沒有做任何操作，現在就有兩個就緒的通道，但在每次select()方法調用之間，只有一個通道就緒了。

selectedKeys()

一旦調用了select()方法，並且返回值表明有一個或更多個通道就緒了，然後可以通過調用selector的selectedKeys()方法，訪問“已選擇鍵集（selected key set）”中的就緒通道。如下所示：

Set selectedKeys = selector.selectedKeys();

• 1

當向 Selector 註冊 Channel 時，Channel.register() 方法會返回一個 SelectionKey 對象。這個對象代表了註冊到該Selector的通道。可以通過SelectionKey的selectedKeySet()方法訪問這些對象。

可以遍歷這個已選擇的鍵集合來訪問就緒的通道。如下：

Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.
    } else if (key.isConnectable()) {
        // a connection was established with a remote server.
    } else if (key.isReadable()) {
        // a channel is ready for reading
    } else if (key.isWritable()) {
        // a channel is ready for writing
    }
    keyIterator.remove();
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

這個循環遍歷已選擇鍵集中的每個鍵，並檢測各個鍵所對應的通道的就緒事件。

注意每次迭代末尾的 keyIterator.remove() 調用。Selector不會自己從已選擇鍵集中移除 SelectionKey 實例。必須在處理完通道時自己移除。下次該通道變成就緒時，Selector會再次將其放入已選擇鍵集中。

SelectionKey.channel() 方法返回的通道需要轉型成你要處理的類型，如 ServerSocketChannel 或 SocketChannel 等。

wakeUp()

某個線程調用select()方法後阻塞了，即使沒有通道已經就緒，也有辦法讓其從select()方法返回。只要讓其它線程在第一個線程調用select()方法的那個對象上調用Selector.wakeup()方法即可。阻塞在select()方法上的線程會立馬返回。

如果有其它線程調用了wakeup()方法，但當前沒有線程阻塞在select()方法上，下個調用select()方法的線程會立即“醒來（wake up）”。

close()

用完 Selector 後調用其 close() 方法會關閉該 Selector，且使註冊到該Selector上的所有SelectionKey實例無效。通道本身並不會關閉。

完整的示例

這裏有一個完整的示例，打開一個Selector，註冊一個通道註冊到這個Selector上(通道的初始化過程略去),然後持續監控這個Selector的四種事件（接受，連接，讀，寫）是否就緒。

Selector selector = Selector.open();
channel.configureBlocking(false);
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
while(true) {
  int readyChannels = selector.select();
  if(readyChannels == 0) continue;
  Set selectedKeys = selector.selectedKeys();
  Iterator keyIterator = selectedKeys.iterator();
  while(keyIterator.hasNext()) {
  SelectionKey key = keyIterator.next();
  if(key.isAcceptable()) {
    // a connection was accepted by a ServerSocketChannel.
  } else if (key.isConnectable()) {
    // a connection was established with a remote server.
  } else if (key.isReadable()) {
    // a channel is ready for reading
  } else if (key.isWritable()) {
    // a channel is ready for writing
  }
    keyIterator.remove();
  }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

分散（Scatter）/聚集（Gather）

分散概念

分散（scatter）：從Channel中讀取是指在讀操作時將讀取的數據寫入多個buffer中。因此，Channel將從Channel中讀取的數據“分散（scatter）”到多個Buffer中。

程序清單 1-1
ByteBuffer header = ByteBuffer.allocate(128);  
ByteBuffer body   = ByteBuffer.allocate(1024);  
ByteBuffer[] bufferArray = { header, body };  
channel.read(bufferArray);  

• 1
• 2
• 3
• 4
• 5

注意buffer首先被插入到數組，然後再將數組作爲 channel.read() 的輸入參數。read() 方法按照 buffer 在數組中的順序將從 channel 中讀取的數據寫入到buffer，當一個 buffer 被寫滿後，channel 緊接着向另一個 buffer 中寫。

Scattering Reads在移動下一個buffer前，必須填滿當前的buffer，這也意味着它不適用於動態消息(譯者注：消息大小不固定)。換句話說，如果存在消息頭和消息體，消息頭必須完成填充（例如 128byte），Scattering Reads才能正常工作。

聚集概念

聚集（gather）：寫入Channel是指在寫操作時將多個buffer的數據寫入同一個Channel，因此，Channel 將多個Buffer中的數據“聚集（gather）”後發送到Channel。

示例1-1
ByteBuffer header = ByteBuffer.allocate(128);  
ByteBuffer body   = ByteBuffer.allocate(1024);  
//write data into buffers  
ByteBuffer[] bufferArray = { header, body };  
channel.write(bufferArray);  

• 1
• 2
• 3
• 4
• 5
• 6

buffer的一個數組被傳遞給了 write() 方法，這個方法寫他們在數組中遇到的接下來的 buffer 的內容。只是這些數據在 buffer 的 position 和 limit 直接被寫。因此，如果一個buffer有一個128字節的容量，但是隻包含了58個字節，只有58個字節可以從 buffer 中寫到 channel 。因此，一個聚集寫操作通過動態可變大小的消息部分會工作的很好，跟分散讀取正好相反。

分散/聚集的應用

scatter / gather經常用於需要將傳輸的數據分開處理的場合。例如，您可能在編寫一個使用消息對象的網絡應用程序，每一個消息被劃分爲固定長度的頭部和固定長度的正文。您可以創建一個剛好可以容納頭部的緩衝區和另一個剛好可以容納正文的緩衝區。當您將它們放入一個數組中並使用分散讀取來向它們讀入消息時，頭部和正文將整齊地劃分到這兩個緩衝區中。

我們從緩衝區所得到的方便性對於緩衝區數組同樣有效。因爲每一個緩衝區都跟蹤自己還可以接受多少數據，所以分散讀取會自動找到有空間接受數據的第一個緩衝區。在這個緩衝區填滿後，它就會移動到下一個緩衝區。

簡單小例子

RandomAccessFile raf1=new RandomAccessFile("d:\\ay.txt", "rw");
//獲取通道
FileChannel channel1 = raf1.getChannel();
//設置緩衝區
ByteBuffer buf1=ByteBuffer.allocate(50);
ByteBuffer buf2=ByteBuffer.allocate(1024);
//分散讀取的時候緩存區應該是有序的，所以把幾個緩衝區加入數組中
ByteBuffer[] bufs={buf1,buf2};
//通道進行傳輸
channel1.read(bufs);
//查看緩衝區中的內容
for (int i = 0; i < bufs.length; i++) {
   //切換爲讀模式
   bufs[i].flip();
}
System.out.println(new String(bufs[0].array(),0,bufs[0].limit()));
System.out.println();
System.out.println(new String(bufs[1].array(),0,bufs[1].limit()));
//聚集寫入
RandomAccessFile  raf2=new RandomAccessFile("d:\\al.txt", "rw");
FileChannel channel2 = raf2.getChannel();
//只能通過通道來進行寫入
channel2.write(bufs);

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

其他通道

​

文件通道

略

Socket管道

Java NIO中的 SocketChannel 是一個連接到 TCP 網絡套接字的通道。可以通過以下2種方式創建 SocketChannel：

• 打開一個SocketChannel並連接到互聯網上的某臺服務器。
• 一個新連接到達 ServerSocketChannel 時，會創建一個 SocketChannel。

打開 SocketChannel

下面是SocketChannel的打開方式：

SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("http://jenkov.com",80));

• 1
• 2
• 3

從 SocketChannel 讀取數據

要從SocketChannel中讀取數據，調用一個read()的方法之一。以下是例子：

ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = socketChannel.read(buf);

• 1
• 2
• 3

首先，分配一個Buffer。從SocketChannel讀取到的數據將會放到這個Buffer中。

然後，調用SocketChannel.read()。該方法將數據從SocketChannel 讀到Buffer中。read()方法返回的int值表示讀了多少字節進Buffer裏。如果返回的是-1，表示已經讀到了流的末尾（連接關閉了）。

寫入 SocketChannel

寫數據到SocketChannel用的是SocketChannel.write()方法，該方法以一個Buffer作爲參數。示例如下：

String newData = "New String to write to file..." + System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
    channel.write(buf);
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

注意SocketChannel.write()方法的調用是在一個while循環中的。Write()方法無法保證能寫多少字節到SocketChannel。所以，我們重複調用write()直到Buffer沒有要寫的字節爲止。

非阻塞模式

可以設置 SocketChannel 爲非阻塞模式（non-blocking mode）.設置之後，就可以在異步模式下調用connect(), read() 和write()了。

connect()

如果SocketChannel在非阻塞模式下，此時調用connect()，該方法可能在連接建立之前就返回了。爲了確定連接是否建立，可以調用finishConnect()的方法。像這樣：

socketChannel.configureBlocking(false);
socketChannel.connect(new InetSocketAddress("http://jenkov.com", 80));
while(! socketChannel.finishConnect() ){
    //wait, or do something else...
}

• 1
• 2
• 3
• 4
• 5
• 6

write()

非阻塞模式下，write()方法在尚未寫出任何內容時可能就返回了。所以需要在循環中調用write()。前面已經有例子了，這裏就不贅述了。

read()

非阻塞模式下,read()方法在尚未讀取到任何數據時可能就返回了。所以需要關注它的int返回值，它會告訴你讀取了多少字節。

不錯的小例子

一下是來自網絡的一個小例子，個人覺得很不錯，就貼到這裏。

class NioClient {
    //管道管理器
    private Selector selector;

    public NioClient init(String serverIp, int port) throws IOException{
        //獲取socket通道
        SocketChannel channel = SocketChannel.open();

        channel.configureBlocking(false);
        //獲得通道管理器
        selector=Selector.open();

        //客戶端連接服務器，需要調用channel.finishConnect();才能實際完成連接。
        channel.connect(new InetSocketAddress(serverIp, port));
        //爲該通道註冊SelectionKey.OP_CONNECT事件
        channel.register(selector, SelectionKey.OP_CONNECT);
        return this;
    }

    public void listen() throws IOException{
        System.out.println("客戶端啓動");
        //輪詢訪問selector
        while(true){
            //選擇註冊過的io操作的事件(第一次爲SelectionKey.OP_CONNECT)
            selector.select();
            Iterator<SelectionKey> ite = selector.selectedKeys().iterator();
            while(ite.hasNext()){
                SelectionKey key = ite.next();
                //刪除已選的key，防止重複處理
                ite.remove();
                if(key.isConnectable()){
                    SocketChannel channel=(SocketChannel)key.channel();

                    //如果正在連接，則完成連接
                    if(channel.isConnectionPending()){
                        channel.finishConnect();
                    }

                    channel.configureBlocking(false);
                    //向服務器發送消息
                    channel.write(ByteBuffer.wrap(new String("send message to server.").getBytes()));

                    //連接成功後，註冊接收服務器消息的事件
                    channel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客戶端連接成功");
                }else if(key.isReadable()){ //有可讀數據事件。
                    SocketChannel channel = (SocketChannel)key.channel();

                    ByteBuffer buffer = ByteBuffer.allocate(10);
                    channel.read(buffer);
                    byte[] data = buffer.array();
                    String message = new String(data);

                    System.out.println("recevie message from server:, size:" + buffer.position() + " msg: " + message);
//                    ByteBuffer outbuffer = ByteBuffer.wrap(("client.".concat(msg)).getBytes());
//                    channel.write(outbuffer);
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        new NioClient().init("127.0.0.1", 9981).listen();
    }
}



class NioServer {
    //通道管理器
    private Selector selector;

    //獲取一個ServerSocket通道，並初始化通道
    public NioServer init(int port) throws IOException{
        //獲取一個ServerSocket通道
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.socket().bind(new InetSocketAddress(port));
        //獲取通道管理器
        selector=Selector.open();
        //將通道管理器與通道綁定，併爲該通道註冊SelectionKey.OP_ACCEPT事件，
        //只有當該事件到達時，Selector.select()會返回，否則一直阻塞。
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        return this;
    }

    public void listen() throws IOException{
        System.out.println("服務器端啓動成功");

        //使用輪詢訪問selector
        while(true){
            //當有註冊的事件到達時，方法返回，否則阻塞。
            selector.select();

            //獲取selector中的迭代器，選中項爲註冊的事件
            Iterator<SelectionKey> ite=selector.selectedKeys().iterator();

            while(ite.hasNext()){
                SelectionKey key = ite.next();
                //刪除已選key，防止重複處理
                ite.remove();
                //客戶端請求連接事件
                if(key.isAcceptable()){
                    ServerSocketChannel server = (ServerSocketChannel)key.channel();
                    //獲得客戶端連接通道
                    SocketChannel channel = server.accept();
                    channel.configureBlocking(false);
                    //向客戶端發消息
                    channel.write(ByteBuffer.wrap(new String("send message to client").getBytes()));
                    //在與客戶端連接成功後，爲客戶端通道註冊SelectionKey.OP_READ事件。
                    channel.register(selector, SelectionKey.OP_READ);

                    System.out.println("客戶端請求連接事件");
                }else if(key.isReadable()){//有可讀數據事件
                    //獲取客戶端傳輸數據可讀取消息通道。
                    SocketChannel channel = (SocketChannel)key.channel();
                    //創建讀取數據緩衝器
                    ByteBuffer buffer = ByteBuffer.allocate(10);
                    int read = channel.read(buffer);
                    byte[] data = buffer.array();
                    String message = new String(data);

                    System.out.println("receive message from client, size:" + buffer.position() + " msg: " + message);
//                    ByteBuffer outbuffer = ByteBuffer.wrap(("server.".concat(msg)).getBytes());
//                    channel.write(outbuffer);
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        new NioServer().init(9981).listen();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106
• 107
• 108
• 109
• 110
• 111
• 112
• 113
• 114
• 115
• 116
• 117
• 118
• 119
• 120
• 121
• 122
• 123
• 124
• 125
• 126
• 127
• 128
• 129
• 130
• 131
• 132
• 133
• 134
• 135

Datagram 通道

Java NIO中的DatagramChannel是一個能收發UDP包的通道。因爲UDP是無連接的網絡協議，所以不能像其它通道那樣讀取和寫入。它發送和接收的是數據包。

Datagram 通道就作爲大家自學的內容。

管道（Pipe）

Java NIO 管道是2個線程之間的單向數據連接。Pipe有一個source通道和一個sink通道。數據會被寫到sink通道，從source通道讀取。

創建管道

通過Pipe.open()方法打開管道。例如：

Pipe pipe = Pipe.open(); 

• 1

向管道寫數據

要向管道寫數據，需要訪問sink通道。像這樣：

Pipe.SinkChannel sinkChannel = pipe.sink(); 

• 1

通過調用SinkChannel的write()方法，將數據寫入SinkChannel,像這樣：

String newData = "New String to write to file..." + System.currentTimeMillis();  
ByteBuffer buf = ByteBuffer.allocate(48);  
buf.clear();  
buf.put(newData.getBytes());  
buf.flip();  
while(buf.hasRemaining()) {  
   <b>sinkChannel.write(buf);</b>  
} 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

從管道讀取數據

從讀取管道的數據，需要訪問source通道，像這樣：

Pipe.SourceChannel sourceChannel = pipe.source(); 

• 1

調用source通道的read()方法來讀取數據，像這樣：

ByteBuffer buf = ByteBuffer.allocate(48);  
int bytesRead = inChannel.read(buf);  

• 1
• 2

read()方法返回的int值會告訴我們多少字節被讀進了緩衝區。

簡單完整實例

//獲取管道
Pipe pipe = Pipe.open();
//獲取Sink 管道
Pipe.SinkChannel sinkChannel = pipe.sink();
//需要寫入數據
String newData = "New String to write to file..." + System.currentTimeMillis();
//新建緩存區
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
//緩存區存放數據
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
    sinkChannel.write(buf);
}
//獲取Source 管道
Pipe.SourceChannel sourceChannel = pipe.source();
ByteBuffer buf2 = ByteBuffer.allocate(48);
int bytesRead = sourceChannel.read(buf2);
while (bytesRead != -1) {
    System.out.println("Read " + bytesRead);
    //buf.flip()的調用，首先讀取數據到Buffer，然後反轉Buffer,接着再從Buffer中讀取數據（注：flip：空翻，反轉）
    buf.flip();
    //判斷是否有剩餘（注：Remaining：剩餘的）
    while(buf.hasRemaining()){
        System.out.print((char) buf.get());
    }
    buf.clear();
    bytesRead = sourceChannel.read(buf);
}
sourceChannel.close();
sinkChannel.close();

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32

AIO編程

AIO的特點

• 讀完了再通知我

• 不會加快IO，只是在讀完後進行通知

• 使用回調函數，進行業務處理

​

AIO的相關代碼：

//AsynchronousServerSocketChannel類
server = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(PORT));

• 1
• 2

使用server上的accept方法

public abstract <A> void accept(A attachment,CompletionHandler<AsynchronousSocketChannel,? super A> handler);

• 1

CompletionHandler爲回調接口，當有客戶端accept之後，就做handler中的事情。

NIO與AIO區別

• NIO是同步非阻塞的，AIO是異步非阻塞的
• 由於NIO的讀寫過程依然在應用線程裏完成，所以對於那些讀寫過程時間長的，NIO就不太適合。而AIO的讀寫過程完成後才被通知，所以AIO能夠勝任那些重量級，讀寫過程長的任務。

結束語

---

讀書感悟

來着果戈理《死魂靈》

• 愉快的談話勝似一切佳餚美饌。
• 一個女人儘管原來在性格上要比男人柔弱無能得多，在有的情況下她卻能夠突然一下子變得強硬堅定起來，不但勝過男人，而且勝過了世界上所有的一切。
• 在一件事情的開初，是不能測度它的全部情狀，以及經過的廣和深。
• 就投機鑽營來說，世故的價值永遠是無可比擬的。

參考文章

【1】http://blog.csdn.net/anxpp/article/details/51512200
【2】http://www.iteye.com/magazines/132-Java-NIO
【3】http://www.jb51.net/article/92448.htm
【4】http://www.cnblogs.com/good-temper/p/5003892.html
【5】http://www.cnblogs.com/fanzhidongyzby/p/4098546.htm
【6】https://www.ibm.com/developerworks/cn/java/l-niosvr/
【7】Netty權威指南
【8】http://ifeve.com/selectors/
【9】http://ifeve.com/socket-channel/