java基础IO

最新推荐文章于 2024-04-01 18:00:08 发布

原创最新推荐文章于 2024-04-01 18:00:08 发布 · 211 阅读

0 ·

CC 4.0 BY-SA版权

复习java基础专栏收录该内容

14 篇文章

订阅专栏

1)Java中有几种类型的流

1、基于字节操作的I/O接口：InputStream和OutputStream

2、基于字符操作的I/O接口：Writer和Reader

3、基于磁盘操作的I/O接口：File

4、基于网络操作的I/O接口：Socket（不在java.io包下）

分类

1、按流的方向：输入流，输出流

2、按流的功能：节点流，处理流

3、按处理单位：字节流，字符流

2）四个基本抽象流，顶级接口

inputStream：字节输入流

outputStream：字节输出流

Reader：字符输入流

Writer：字符输出流

3）字节输入流类型（字节输出流类似）

ByteArrayInputStream：字节数组输入流，该类的功能就是从字节数组(byte[])中进行以字节为单位的读取，也就是将资源文件都以字节的形式存入到该类中的字节数组中去，我们拿也是从这个字节数组中拿

PipedInputStream：管道字节输入流，它和PipedOutputStream一起使用，能实现多线程间的管道通信

FilterInputStream ：装饰者模式中处于装饰者，具体的装饰者都要继承它，所以在该类的子类下都是用来装饰别的流的，也就是处理类。具体装饰者模式在下面会讲解到，到时就明白了

BufferedInputStream：缓冲流，对处理流进行装饰，增强，内部会有一个缓存区，用来存放字节，每次都是将缓存区存满然后发送，而不是一个字节或两个字节这样发送。效率更高

DataInputStream：数据输入流，它是用来装饰其它输入流，它“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”

FileInputSream：文件输入流。它通常用于对文件进行读取操作

ObjectInputStream：对象输入流，用来提供对“基本数据或对象”的持久存储。通俗点讲，也就是能直接传输对象（反序列化中使用，使用类需要继承Serializable类）。

3）字符输入流

CharReader、StringReader 是两种基本的介质流，它们分别将Char 数组、String中读取数据。PipedReader 是从与其它线程共用的管道中读取数据。
BufferedReader 很明显就是一个装饰器，它和其子类负责装饰其它Reader 对象。
FilterReader 是所有自定义具体装饰流的父类，其子类PushbackReader 对Reader 对象进行装饰，会增加一个行号。
InputStreamReader 是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。FileReader 可以说是一个达到此功能、常用的工具类，在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。
4）字节流字符流使用范围

字节流一般用来处理图像，视频，以及PPT，Word类型的文件。字符流一般用于处理纯文本类型的文件，如TXT文件等

5）System类

System.in（标准输入），通常代表键盘输入。

System.out（标准输出）：通常写往显示器。

System.err（标准错误输出）：通常写往显示器。

6）使用了装饰者设计模式

7）JDK1.8新增流操作Steam

详细

8）缓存I/O

先将I/O的数据缓存到文件系统的页缓存（先被拷贝到操作系统的内核），然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。

即缓存I/O需要在应用程序地址空间和内核进行多次数据拷贝操作，多cpu造成很大的开销。

总结：IO需要进行两个阶段

1. 等待数据准备
2. 将数据从内核拷贝到进程中

9）阻塞I/O（blocking IO）

在linux默认情况下所以的socket都是阻塞的。

此时用户线程在IO过程中被阻塞，不能做任何事情，对CPU的资源利用率不高。

例：你在钓鱼的时候需要诱饵，只能先回家拿，拿好了才能回来继续钓鱼，没拿到之前钓鱼行为是阻塞的不进行的。

10）非阻塞I/O（nonblocking IO）

linux下，可以通过设置socket使其变为non-blocking。

流程：当用户进程发起IO请求时，如果内核（kernel）中的数据并未准备好，那么它并不会block进程，而是放回一个error。

当用户线程发起一个IO read请求时，并不需要阻塞等待，而是马上得到一个结果。如果结果是error，说明数据并未准备好，那么线程可以再次发起read请求，直到内核中数据准备完毕，并且又再次收到用户线程的read请求，那么它会马上把数据从内核中拷贝到用户内存中去，然后返回。

nonblocking IO的特点是用户进程需要不断的主动询问内核（kernel）数据好了没有。

11）多路复用I/O（IO multiplexing）

即select，poll，epoll，也称为事件驱动。

它的基本原理就是select，poll，epoll（都是系统调用）这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了（到达内核），就通知用户进程，再把数据拷贝到用户内存中。

当用户进程调用了select，那么整个进程会被block，而同时，kernel会“监视”所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从kernel拷贝到用户进程。

所以总的看来似乎和非阻塞IO差多少，而且还多了个系统调用。事实上性能可以说还比非阻塞差点（处理的连接数不是很高的话）。但它的优势在于可以同时监控多个IO连接。

12）异步IO（asynchronous IO）

发起read操作后进程立马返回，整个Io过程不会产生任何block。kernel会等等数据准备完成，然后将数据拷贝到用户内存。当这一切都完成后，kernel会给用户进程发送一个signal，告诉它read操作完成了。

13）select

int select (int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

通过三个文件描述符和超时机制监控

当

readfds可读

writefds可写

exceptfds可except

timeout或者超时timeout指定等待时间，如果立即返回设为null即可），函数返回。

14）poll

int poll (struct pollfd *fds, unsigned int nfds, int timeout);
struct pollfd {
    int fd; /* file descriptor */
    short events; /* requested events to watch 监控的事件*/
    short revents; /* returned events witnessed 发生的事件*/
};

可以看到poll使用的是pollfd的指针实现，而不是像select一样使用三个位图。

15）epoll

引用来源：作者：人云思云
链接：https://segmentfault.com/a/1190000003063859

epoll操作过程需要三个接口，分别如下：

int epoll_create(int size)；//创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
1. int epoll_create(int size);
创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大，这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值，参数size并不是限制了epoll所能监听的描述符最大个数，只是对内核初始分配内部数据结构的一个建议。
当创建好epoll句柄后，它就会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)；
函数是对指定描述符fd执行op操作。
- epfd：是epoll_create()的返回值。
- op：表示op操作，用三个宏来表示：添加EPOLL_CTL_ADD，删除EPOLL_CTL_DEL，修改EPOLL_CTL_MOD。分别添加、删除和修改对fd的监听事件。
- fd：是需要监听的fd（文件描述符）
- epoll_event：是告诉内核需要监听什么事，struct epoll_event结构如下：

struct epoll_event {
  __uint32_t events;  /* Epoll events */
  epoll_data_t data;  /* User data variable */
};

//events可以是以下几个宏的集合：
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里
3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待epfd上的io事件，最多返回maxevents个事件。
参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。

epoll对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下：
　　LT模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。
　　ET模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。

同步和异步的区别

只有异步IO是异步IO，
其他3种：阻塞IO、非阻塞IO、多路复用IO都是同步的。
这是因为其他三种IO在执行真实IO操作的过程中都有进程阻塞的阶段，而异步IO在整个过程中进程都没有被阻塞。非阻塞IO在内核数据就绪，拷贝到用户空间的阶段也是阻塞的，因此也是同步IO。

刷题时间到剑指offer走起

题目描述

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。例如

adee
sfcs
abce

矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

public class Solution {
    int[][] shuijiao = {{1,0},{-1,0},{0,1},{0,-1}};
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str){
        boolean[] vis = new boolean[matrix.length];//申请标记数组，访问过的为
        for(int i = 0; i < rows; i++){
            for(int j = 0; j < cols; j++){
                if(matrix[cols*i+j] == str[0]){//找的第一个相同的
                    vis[cols*i+j] = true;
                    if(dfs(matrix, rows, cols, str, i, j, 1, vis) == true){
                        return true;
                    }
                    vis[cols*i+j] = false;//来到这里说明没有找的变回初始化
                }
            }
        }
        return false;
    }
    boolean dfs(char[] matrix, int rows, int cols, char[] str, int i, int j, int len, boolean[] vis){
        if(len == str.length)
                return true;
        int l,r;
        boolean f = false;
        for(int k = 0; k < 4; k++){
            l = i + shuijiao[k][0];
            r = j + shuijiao[k][1];
            if(l >= 0 && l < rows && r >= 0 && r<cols && vis[cols*l+r] == false && matrix[cols*l+r] == str[len]){
                vis[cols*l+r] = true;
                f = dfs(matrix, rows, cols, str, l, r, len+1, vis);
                vis[cols*l+r] = false;
            }
            if(f == true)
                return true;
        }
        return false;
    }

}