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

时间:2021-2-20 作者:admin

IO基础

1 输入与输出

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

2 流

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

2.1 字节流

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

2.2 字符流

字符流:以1char(2 byte 16bit)作为一个数据单元,数据流的最小数据单元是字符。这是因为Java采用Unicode编码,一个字符占用两个字节。
【JAVA核心知识】6.1: JAVA  IO基础


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是经过哪些操作完成的,他只是发起一个请求,并在接收到来自内核的数据就绪通知后去使用数据即可。

4.3 同步IO与异步IO图解

【JAVA核心知识】6.1: JAVA  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等概念)

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。