【JAVA核心知识】6.1: JAVA IO基础

1 输入与输出

IO即Input-Output，输入与输出。
如何确定属于与输出：以应用程序的视角看待数据，数据从外部到应用程序即输入(Input)。数据从应用程序到外部的过程即为输出(Output)。Reader是应用程序作为阅读者，自然是数据从外部进入应用程序，也是输入。Writer是应用程序作为写数据的人，数据从应用程序到外部，也是输出。

2 流

Java将数据的输入输出抽象为流。流是一组有序的，单向的，有起点和终点的的数据集合。就像水流。根据最小数据单元又分为字节流和字符流。

2.1 字节流

字节流：以1byte(8 bit)作为一个数据单元，数据流的最小数据单元是字节。

2.2 字符流

字符流：以1char(2 byte 16bit)作为一个数据单元，数据流的最小数据单元是字符。这是因为Java采用Unicode编码，一个字符占用两个字节。

IO分类：图片来源IO流体系图

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是经过哪些操作完成的，他只是发起一个请求，并在接收到来自内核的数据就绪通知后去使用数据即可。
【JAVA核心知识】6.3: JAVA AIO便是介绍了采用异步IO模型的JAVA AIO。

4.3 同步IO与异步IO图解

4.4 生活举例

张三(用户线程)去餐馆吃饭时间感觉饭太干了，就准备去点餐处买了一瓶水(read操作)喝。同步IO下张三告诉服务员他需要一瓶水，然后张三就会等待服务将水送到他的餐桌上(内核拷贝)或者告诉他现在没有水(数据未就绪标识)。即张三要得到这次买水的结果才能继续动作。而异步IO下，张三只是告诉服务员他需要一瓶水(向内核发送读取数据请求)，然后就可以去干自己的事情了，服务员如果有水的话就会把水送到张三的餐桌上，如果没有水就会等水来了再送，而且这个等水的过程完全是服务员在等，和张三没有任何关系。等服务将水送到张三的餐桌上后，就会告诉张三水我已经放到你餐桌上了。整个过程张三不需要关注服务员都做了什么，他只关注我发起了一个买水请求，然后收到水就绪消息后去喝水就行了。

5 多路复用IO

多路复用IO用一个线程不断的去轮询socket，只有socket有实际的读写事件时，才真正调用实际的IO操作。而且多路复用IO与非阻塞IO不同的是多路复用IO轮询socket是在内核中进行的，而不是用户线程进行轮询的。因此多路复用IO较于非阻塞IO有更低的资源占用率，更高的效率。但是因为单线程的轮询，如果一个事件响应时间过长，会导致后续的事件迟迟得不到响应，影响后续的轮询。
【JAVA核心知识】6.2: JAVA NIO便是介绍了采用多路复用IO模型的JAVA NIO。

生活举例

张三要去水果店买水果，李四要去奶茶店买奶茶，王五要去包子店买包子。对于非阻塞IO来说，是张三去水果店，如果水果还没到水果店主就告诉张三水果还没到，李四去奶茶店，如果奶茶还没到奶茶店主就告诉李四奶茶还没到，王五去包子店，如果包子还没好包子店主就告诉王五包子还没好。但是多路复用IO是张三李四王五告诉赵六自己要做什么，然后赵六就一遍一遍的去水果店，奶茶店，包子店去问询，一旦哪个商品就绪就买来给对应的人。不过要注意的是，因为赵六一个人在轮询三家店，如果奶茶店和包子店同时准备好，赵六先到了奶茶店，那么在奶茶店购物的过程中，包子店虽然货物到了但依然需要等待，造成一定的延迟。

6 信号驱动IO

信号驱动IO当用户线程发起一个IO操作请求后，会给对应的socket注册一个信号函数，然后用户线程继续执行，当内核数据就绪后就会发送一个信号给用户线程，用户线程接到信号后就在信号函数中来进行实际的IO操作。
与异步IO不同的是信号驱动IO在用户接到信号时只是代表着数据就绪了，后续用户线程还要调用信号函数进行实际的IO操作，而异步IO在接收到信号时表示IO操作已经完成，不需要再进行额外的操作，而是可以直接使用数据。

PS：
【JAVA核心知识】系列导航 [持续更新中…]
上篇导航：5: JVM的类加载
下篇导航：6.2: JAVA NIO
欢迎关注…

参考资料：
Java 基础之详解 Java IO
IO模式和IO多路复用（阻塞IO、非阻塞IO、同步IO、异步IO等概念）