使用懒加载 + 零拷贝后，程序的秒开率提升至99.99%

2024-06-12

字数统计: 4k字 | 阅读时长: 14分 | 本文总阅读量0次

一、5秒钟加载一个页面的真相

今天在修改前端页面的时候，发现程序中有一个页面的加载速度很慢，差不多需要5秒，这其实是难以接受的，我也不知道为什么上线这么长时间了，没人提过这个事儿。

我记得有一个词儿，叫秒开率。

秒开率是指能够在1秒内完成页面的加载。

查询的时候，会访问后台数据库，查询前20条数据，按道理来说，这应该很快才对。追踪代码，看看啥问题，最后发现问题有三：

1.表中有一个BLOB大字段，存储着一个PDF模板，也就是上图中的运费模板；

2.查询后会将这个PDF模板存储到本地磁盘点

3.击线上显示，会读取本地的PDF模板，通过socket传到服务器。

大字段批量查询、批量文件落地、读取大文件并进行网络传输，不慢才怪，这一顿骚操作，5秒能加载完毕，已经烧高香了。

二、优化四步走

1、“懒加载”

经过调查发现，这个PDF模板只有在点击运费模板按钮时才会使用。

优化1：在点查询按钮时，不查询PDF模板；
优化2：点击运费模板时，根据uuid去查询，这样既能触发索引，也不用按时间排序，只是查询单条，速度快了很多很多，我愿称你为“懒加载”。
优化3：通过异步，将文件保存到磁盘中。

2、线上显示 = 就读取一个文件，为什么会慢呢？

打开代码一看，居然是通过FileReader读取的，我了个乖乖~这有什么问题吗？

都是从百度拷贝过来的，百度还会有错吗？而且也测试了，没问题啊。

嗯，对，是没问题，是可以实现需求，可是，为什么用这个？不知道。更别说效率问题了~

优化4：通过缓冲流读取文件

三、先从上帝视角，了解一下啥子是IO流

Java I/O (Input/Output) 是对传统 I/O 操作的封装，它是以流的形式来操作数据的。

1.InputStream代表一个输入流，它是一个抽象类，不能被实例化。InputStream定义了一些通用方法，如read()和skip()等，用于从输入流中读取数据；

2.OutputStream代表一个输出流，它也是一个抽象类，不能被实例化。OutputStream定义了一些通用方法，如write()和flush()等，用于向输出流中写入数据；

3.除了字节流，Java还提供字符流，字符流类似于字节流，不同之处在于字符流是按字符读写数据，而不是按字节。Java中最基本的字符流是Reader和Writer，它们是基于InputStream和OutputStream的转换类，用于完成字节流与字符流之间的转换。

4.BufferedInputStream和BufferedOutputStream是I/O包中提供的缓冲输入输出流。它们可以提高I/O操作的效率，具有较好的缓存机制，能够减少磁盘操作，缩短文件传输时间。使用BufferedInputStream和 BufferedOutputStream进行读取和写入时，Java会自动调整缓冲区的大小，使其能够适应不同的数据传输速度。

5.可以读取或写入 Java对象的流，比较典型的对象流包括ObjectInputStream 和ObjectOutputStream，将Java对象转换为字节流进行传输或存储；

在上一篇《增加索引+异步+不落地后，从12h优化到15min》中，提到了4种优化方式，数据库优化、复用优化、并行优化、算法优化。

其中Buffered缓冲流就属于复用优化的一种，这个页面的查询完全可以通过复用优化优化一下。

四、写个栗子，测试一下

1、通过字符输入流FileReader读取

FileReader连readLine()方法都没有，我也是醉了~

private static int readFileByReader(String filePath) {
    int result = 0;
    try (Reader reader = new FileReader(filePath)) {
        int value;
        while ((value = reader.read()) != -1) {
            result += value;
        }
    } catch (Exception e) {
        System.out.println("readFileByReader异常：" + e);
    }
    return result;
}

2、通过缓冲流BufferedReader读取

private static String readFileByBuffer(String filePath) {
    StringBuilder builder = new StringBuilder();
    try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
        String data = null;
        while ((data = reader.readLine())!= null){
            builder.append(data);
        }
    }catch (Exception e) {
        System.out.println("readFileByReader异常：" + e);
    }
    return builder+"";
}

通过循环模拟了150000个文件进行测试，FileReader耗时8136毫秒，BufferedReader耗时6718毫秒，差不多相差1秒半的时间，差距还是相当大的，俗话说得好，水滴石穿。

同样是read方法，只不过是包了一层，有啥不同呢？

BufferedReader 是一个缓冲字符输入流，可以对 FileRead 进行包装，提供了一个缓存数组，将数据按照一定规则读取到缓存区中，输入流每次读取文件数据时都需要将数据进行字符编码，而 BufferedReader 的出现，降低了输入流访问数据源的次数，将一定大小的数据一次读取到缓存区并进行字符编码，从而提高 IO 的效率。

如果没有缓冲，每次调用 read() 或 readLine() 都可能导致从文件中读取字节，转换为字符，然后返回，这可能非常低效。

就像取快递一样，在取快递的时候，肯定是想一次性的取完，避免再来一趟。

FileReader就相当于一件一件的取，乐此不疲；
BufferedReader就相当于，你尽可能多的拿你的快递，可是这也有个极限，比如你一次只能拿5件快递，这个 5 就相当于缓冲区，效率上，提升数倍。

对 FileRead 进行包装变成了BufferedReader缓冲字符输入流，其实，Java IO流就是最典型的装饰器模式，装饰器模式通过组合替代继承的方式在不改变原始类的情况下添加增强功能，主要解决继承关系过于复杂的问题，之前整理过一篇装饰器模式，这里就不论述了。

3、再点进源码瞧瞧。

（1）FileReader.read()源码很简单，就是直接读取

1
2
3

public int read(char cbuf[], int off, int len) throws IOException {
   return in.read(cbuf, off, len);
}

（2）BufferedReader.read()的源码就较为复杂了，看一下它的核心方法

fill()private void fill() throws IOException {
   int dst;
    if (markedChar <= UNMARKED) {
        /* No mark */
        dst = 0;
    } else {
        /* Marked */
        int delta = nextChar - markedChar;
        if (delta >= readAheadLimit) {
            /* Gone past read-ahead limit: Invalidate mark */
            markedChar = INVALIDATED;
            readAheadLimit = 0;
            dst = 0;
        } else {
            if (readAheadLimit <= cb.length) {
                /* Shuffle in the current buffer */
                System.arraycopy(cb, markedChar, cb, 0, delta);
                markedChar = 0;
                dst = delta;
            } else {
                /* Reallocate buffer to accommodate read-ahead limit */
                char ncb[] = new char[readAheadLimit];
                System.arraycopy(cb, markedChar, ncb, 0, delta);
                cb = ncb;
                markedChar = 0;
                dst = delta;
            }
            nextChar = nChars = delta;
        }
    }

    int n;
    do {
        n = in.read(cb, dst, cb.length - dst);
    } while (n == 0);
    if (n > 0) {
        nChars = dst + n;
        nextChar = dst;
    }
}

核心方法fill()：

1.字符缓冲输入流，底层有一个8192个元素的缓冲字符数组，当缓冲区的内容读完时，将使用 fill() 方法从硬盘中读取数据填充缓冲数组；

2.字符缓冲输出流，底层有一个8192个元素的缓冲字符数组，使用flush方法将缓冲数组中的内容写入到硬盘当中；

3.使用缓冲数组之后，程序在运行的大部分时间内都是内存和内存直接的数据交互过程。内存直接的操作效率是比较高的。并且降低了CPU通过内存操作硬盘的次数；

4.关闭字符缓冲流，都会首先释放对应的缓冲数组空间，并且关闭创建对应的字符输入流和字符输出流。

既然缓冲这么好用，为啥jdk将缓冲字符数组设置的这么小，才8192个字节？这是一个比较折中的方案，如果缓冲区太大的话，就会增加单次读写的时间，同样内存的大小也是有限制的，不可能都让你来干这个一件事。

很多小伙伴也肯定用过它的read(char[] cbuf)，它内部维护了一个char数组，每次写/读数据时，操作的是数组，这样可以减少IO次数。

（3）buffer四大属性

1.mark：标记

2.position：位置，下一个要被读或写的元素的索引，每次读写缓冲区数据时都会改变改值，为下次读写作准备

3.limit：表示缓冲区的当前终点，不能对缓冲区超过极限的位置进行读写操作。且极限是可以修改的

4.capacity：容量，即可以容纳的最大数据量；在缓冲区创建时被设定并且不能改变。

4、缓冲流：4次上下文切换+4次拷贝

传统IO执行的话需要4次上下文切换（用户态->内核态->用户态->内核态->用户态）和4次拷贝。

1.磁盘文件DMA拷贝到内核缓冲区

2.内核缓冲区CPU拷贝到用户缓冲区

3.用户缓冲区CPU拷贝到Socket缓冲区

4.Socket缓冲区DMA拷贝到协议引擎。

五、NIO之FileChannel

NIO中比较常用的是FileChannel，主要用来对本地文件进行 IO 操作。

1、FileChannel 常见的方法有

1.read，从通道读取数据并放到缓冲区中；

2.write，把缓冲区的数据写到通道中；

3.transferFrom，从目标通道中复制数据到当前通道；

4,transferTo，把数据从当前通道复制给目标通道。

2、关于Buffer 和 Channel的注意事项和细节

1.ByteBuffer支持类型化的put和get, put放入的是什么数据类型，get就应该使用相应的数据类型来取出，否则可能有 BufferUnderflowException 异常；

2.可以将一个普通Buffer 转成只读Buffer；

3.NIO 还提供了 MappedByteBuffer，可以让文件直接在内存（堆外的内存）中进行修改，而如何同步到文件由NIO 来完成；

4.NIO 还支持通过多个 Buffer (即 Buffer 数组) 完成读写操作，即 Scattering 和 Gathering。

3、Selector(选择器)

1.Java的NIO，用非阻塞的IO方式。可以用一个线程，处理多个的客户端连接，就会使用到Selector(选择器)；

2.Selector 能够检测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。

3.只有在连接/通道真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程。

4,避免了多线程之间的上下文切换导致的开销。

4、selector的相关方法

1.open();//得到一个选择器对象

2.select(long timeout);//监控所有注册的通道，当其中有IO操作可以进行时，将对应的SelectionKey加入到内部集合中并返回，参数用来设置超时时间

3.selectedKeys();//从内部集合中得到所有的SelectionKey。

六、内存映射技术mmap

1、文件映射

传统的文件I/O操作可能会变得很慢，这时候mmap就闪亮登场了。

mmap（Memory-mapped files）是一种在内存中创建映射文件的机制，它可以使我们像访问内存一样访问文件，从而避免频繁的文件I/O操作。

使用mmap的方式是在内存中创建一个虚拟地址，然后将文件映射到这个虚拟地址上，这个映射的过程是由操作系统完成的。

实现映射后，进程就可以采用指针的方式读写操作这一段内存，系统会自动回写到对应的文件磁盘上，这样就完成了对文件的读取操作，而不用调用 read、write 等系统函数。

内核空间对这段区域的修改也会直接反映用户空间，从而可以实现不同进程间的文件共享。

2、Java中使用mmap

在Java中，mmap技术主要使用了JavaNIO（New IO）库中的FileChannel 类，它提供了一种将文件映射到内存的方法，称为MappedByteBuffer。MappedByteBuffe是ByteBuffer的一个子类，它扩展了ByteBuffer的功能，可以直接将文件映射到内存中。

根据文件地址创建了一层缓存当作索引，放在虚拟内存中，使用时会根据的地址，直接找到磁盘中文件的位置，把数据分段load到系统内存(pagecache)中。

public static String readFileByMmap(String filePath) {
    File file = new File(filePath);
    String ret = "";
    StringBuilder builder = new StringBuilder();
    try (FileChannel channel = new RandomAccessFile(file, "r").getChannel()) {
        long size = channel.size();

        // 创建一个与文件大小相同的字节数组
        ByteBuffer buffer = ByteBuffer.allocate((int) size);

        // 将通道上的所有数据都读入到buffer中
        while (channel.read(buffer) != -1) {}

        // 切换为只读模式
        buffer.flip();

        // 从buffer中获取数据并处理
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);

        ret = new String(data);
    } catch (IOException e) {
        System.out.println("readFileByMmap异常：" + e);
    }
    return ret;
}