1 輸入與輸出

IO即Input-Output，輸入與輸出，
如何確定屬于與輸出：以應用程式的視角看待資料，資料從外部到應用程式即輸入(Input)，資料從應用程式到外部的程序即為輸出(Output)，Reader是應用程式作為閱讀者，自然是資料從外部進入應用程式，也是輸入，Writer是應用程式作為寫資料的人，資料從應用程式到外部，也是輸出，

2 流

Java將資料的輸入輸出抽象為流，流是一組有序的，單向的，有起點和終點的的資料集合，就像水流，根據最小資料單元又分為位元組流和字符流，

2.1 位元組流

位元組流：以1byte(8 bit)作為一個資料單元，資料流的最小資料單元是位元組，

2.2 字符流

字符流：以1char(2 byte 16bit)作為一個資料單元，資料流的最小資料單元是字符，這是因為Java采用Unicode編碼，一個字符占用兩個位元組，

3 阻塞IO與非阻塞IO

無論阻塞IO還是非阻塞IO在資料準備就緒的情況下都是一樣的，即將就緒資料拷貝至用戶執行緒，不同的是阻塞IO與非阻塞IO在資料未準備就緒時的應對情況，

3.1 阻塞IO

阻塞IO在資料未準備就緒時用戶執行緒處于阻塞狀態:當用戶執行緒發起IO請求時，內核會查看資料是否準備就緒，如果未準備就緒就會等待資料準備就緒，在這個期間執行緒處于阻塞狀態，用戶執行緒交出CPU，在資料準備就緒后，內核將資料拷貝到用戶執行緒，用戶執行緒解除阻塞狀態，對資料進行處理，

Socket是典型的阻塞IO：
Server端：

package io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 服務端
 */
public class Server {
    
    public static void main(String[] args) {
        // 用執行緒池的意義是處理多個客戶端的請求，這里雖然只有自己的一個模擬客戶端，但是做戲做全套
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        try {
            // 服務端提供8080埠
            ServerSocket server = new ServerSocket(8080);
            System.out.println("Server Start...");
            // 回圈的意義是一直阻塞取請求處理
            while(true) {
                // 這里是阻塞的,沒訊息過來就一直等待
                Socket stock = server.accept();
                System.out.println("服務端拿到請求,提交給執行緒池處理:" + new Date());
                threadPool.execute(getDealRun(stock));
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    private static Runnable getDealRun(final Socket stock) {
        Runnable run = new Runnable() {
            
            @Override
            public void run() {
                try {
                    // 讀取請求
                    BufferedReader br = new BufferedReader(new InputStreamReader(stock.getInputStream()));
                    String req = br.readLine();
                    System.out.println("服務端接收到客戶端請求：[" + req + "]    接收時間：" +  new Date());
                    PrintStream ps = new PrintStream(stock.getOutputStream());
                    Thread.sleep(2000);  // 模擬處理程序以制造停頓
                    // 發送回應
                    System.out.println("服務端發送回應：" + new Date());
                    ps.println(req + "已處理");
                    System.out.println("服務端回應已發送：" + new Date());
                    // 關閉連接,這里應該改finally里面做，且要分別try-catch,這里圖方便，縮減示例行數，放到這里了
                    ps.close();
                    br.close();
                    stock.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        return run;
    }
}

Client端：

package io;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Date;
/**
 * 客戶端
 */
public class Client {
    public static void main(String[] args) {
        try {
            Socket client = new Socket("localhost", 8080);
            System.out.println("Client Start...");
            BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
            PrintStream ps = new PrintStream(client.getOutputStream());
            // 發送請求
            System.out.println("客戶端開始發送請求：" + new Date());
            ps.println("TEST");
            System.out.println("客戶端請求已發送：" + new Date());
            // 讀取回應
            System.out.println("客戶端等待回應：" + new Date());
            // 可以看到這里是阻塞的，一直等待回應回來才繼續執行
            String resp = br.readLine();
            System.out.println("客戶端讀取到回應：" + new Date());
            System.out.println("回應為:" + resp);
            br.close();
            ps.close();
            client.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Server端運行結果：

Server Start...
服務端拿到請求,提交給執行緒池處理:Mon Nov 23 17:28:06 CST 2020
服務端接收到客戶端請求：[TEST]    接收時間：Mon Nov 23 17:28:06 CST 2020
服務端發送回應：Mon Nov 23 17:28:08 CST 2020
服務端回應已發送：Mon Nov 23 17:28:08 CST 2020

Client端運行結果：

Client Start...
客戶端開始發送請求：Mon Nov 23 17:28:06 CST 2020
客戶端請求已發送：Mon Nov 23 17:28:06 CST 2020
客戶端等待回應：Mon Nov 23 17:28:06 CST 2020
客戶端讀取到回應：Mon Nov 23 17:28:08 CST 2020
回應為:TEST已處理

根據列印的時間可以看到，Client端在接收到Server端的回應之前一直處于阻塞狀態，

3.2 非阻塞IO

非阻塞IO在資料未準備就緒是會直接回傳未就緒標識：當用戶執行緒發起IO請求時，內核會查看資料是否準備就緒，如果未就緒內核會直接回傳一個標識給用戶執行緒，至于后續用戶執行緒是繼續詢問還是結束請求則不屬于非阻塞IO的概念范圍，
FileReader便屬于非阻塞IO：

package io;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FilterReader;

public class FileReaderDemo {
    public static void main(String[] args) {
        File file = new File("source/fileReaderTxtFile.txt");
        try {
            FileReader fr = new FileReader(file);
            int c = fr.read();
            // -1即資料未就緒標識
            while (-1 != c) {
                System.out.println((char)c);
                c = fr.read();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

fileReaderTxtFile.txt檔案：

mytest

運行結果：

m
y
t
e
s
t

可以看到，當沒有資料時read方法會回傳-1做為資料未就緒標識，

3.3 生活舉例

張三(用戶執行緒)去餐館吃飯時間感覺飯太干了，就去點餐處買了一瓶水(read操作)喝，在有水(資料就緒)的時間服務員就直接把水送到張三的餐桌上(內核拷貝資料到用戶執行緒)，張三就可以喝水解渴了(使用資料)，但是如果店里現在還沒有水(資料)，阻塞IO的情況下服務員(內核)并不會告訴張三(用戶執行緒)現在沒有水(資料)了，張三(用戶執行緒)就一直坐在那里等服務把水給他(阻塞)，期間張三就只能坐在那里等水不能做其它事情，非阻塞IO下服務員(內核)則會告訴張三(用戶執行緒)，現在店里沒有水(資料未就緒標識)，張三(用戶執行緒)知道這個訊息后就可以坐在那里干些其他的事情，如果玩會手機，至于張三是一會再去問一遍還是直接不要水開吃就不是非阻塞IO的概念范圍了，

4 同步IO與異步IO

同步IO與異步IO的區別在于用戶執行緒和內核的互動方式，

4.1 同步IO

同步IO相當于一問一答，用戶執行緒發起IO操作后，需要得到這次IO操作的結果才能繼續下去，上面所說的阻塞IO,非阻塞IO，以及后面要說的多路復用IO都屬于同步IO，

4.2 異步IO

異步IO模型用戶執行緒發起read操作只是相當于發了一個read請求給內核，內核收到請求會立即回傳，表示請求發送成功了，之后用戶執行緒可以立刻去做其它事情，如果沒有資料，內核就會等待資料準備完成，但是這個等待程序和執行緒沒有任何系，資料準備完成的情況下內核會將準備好的資料拷貝到用戶執行緒，拷貝完成后內核會給用戶執行緒一個信號告訴他read操作已經完成，可以使用資料了，整個程序用戶執行緒無需關注實際的IO是經過哪些操作完成的，他只是發起一個請求，并在接收到來自內核的資料就緒通知后去使用資料即可，

4.3 同步IO與異步IO圖解

4.4 生活舉例

張三(用戶執行緒)去餐館吃飯時間感覺飯太干了，就準備去點餐處買了一瓶水(read操作)喝，同步IO下張三告訴服務員他需要一瓶水，然后張三就會等待服務將水送到他的餐桌上(內核拷貝)或者告訴他現在沒有水(資料未就緒標識)，即張三要得到這次買水的結果才能繼續動作，而異步IO下，張三只是告訴服務員他需要一瓶水(向內核發送讀取資料請求)，然后就可以去干自己的事情了，服務員如果有水的話就會把水送到張三的餐桌上，如果沒有水就會等水來了再送，而且這個等水的程序完全是服務員在等，和張三沒有任何關系，等服務將水送到張三的餐桌上后，就會告訴張三水我已經放到你餐桌上了，整個程序張三不需要關注服務員都做了什么，他只關注我發起了一個買水請求，然后收到水就緒訊息后去喝水就行了，

5 多路復用IO

多路復用IO用一個執行緒不斷的去輪詢socket，只有socket有實際的讀寫事件時，才真正呼叫實際的IO操作，而且多路復用IO與非阻塞IO不同的是多路復用IO輪詢socket是在內核中進行的，而不是用戶執行緒進行輪詢的，因此多路復用IO較于非阻塞IO有更低的資源占用率，更高的效率，但是因為單執行緒的輪詢，如果一個事件回應時間過長，會導致后續的事件遲遲得不到回應，影響后續的輪詢，

生活舉例

張三要去水果店買水果，李四要去奶茶店買奶茶，王五要去包子店買包子，對于非阻塞IO來說，是張三去水果店，如果水果還沒到水果店主就告訴張三水果還沒到，李四去奶茶店，如果奶茶還沒到奶茶店主就告訴李四奶茶還沒到，王五去包子店，如果包子還沒好包子店主就告訴王五包子還沒好，但是多路復用IO是張三李四王五告訴趙六自己要做什么，然后趙六就一遍一遍的去水果店，奶茶店，包子店去問詢，一旦哪個商品就緒就買來給對應的人，不過要注意的是，因為趙六一個人在輪詢三家店，如果奶茶店和包子店同時準備好，趙六先到了奶茶店，那么在奶茶店購物的程序中，包子店雖然貨物到了但依然需要等待，造成一定的延遲，

6 信號驅動IO

信號驅動IO當用戶執行緒發起一個IO操作請求后，會給對應的socket注冊一個信號函式，然后用戶執行緒繼續執行，當內核資料就緒后就會發送一個信號給用戶執行緒，用戶執行緒接到信號后就在信號函式中來進行實際的IO操作，
與異步IO不同的是信號驅動IO在用戶接到信號時只是代表著資料就緒了，后續用戶執行緒還要呼叫信號函式進行實際的IO操作，而異步IO在接收到信號時表示IO操作已經完成，不需要再進行額外的操作，而是可以直接使用資料，

PS：
JAVA核心知識系列，下篇預告：6.2: JAVA NIO，歡迎關注，

參考資料：
Java 基礎之詳解 Java IO
IO模式和IO多路復用（阻塞IO、非阻塞IO、同步IO、異步IO等概念）