inputstream 获取文件_从HTTP到文件的极致优化（零拷贝实现）

你的名字 2023-01-01 10:50 73阅读 0赞

# 从HTTP到文件 #

*  FileChannel 和非直接模式 Buffer vs. FileChannel 和直接模式 Buffer
 *  FileChannel.transferTo() vs. FileChannel.transferFrom() vs. FileChannel.map()
 *  三种 Files.copy() 方法
 *  FileChannel 和非直接模式 Buffer vs. FileChannel.transferTo() vs. Path 到 Path

**背景：如何高效的从HTTP请求响应数据，写入到文件中。**

http请求返回内容`response.getEntity().getContent()`

可以获取本次调用的InputStream，InputStream实际上是本次请求打开的socket返回的InputStream，可以读取socket的数据。

详细内容可以参考`socket.getInputStream()`方法的注释，来获取官方说明。

我们的目的是把从InputStream中读取的数据，写入到文件中。

# 1 常规方法 #

普通的解析是利用\`\`org.apache.http.util.EntityUtil.toString( final HttpEntity entity, final Charset defaultCharset)\`方法，读取Stream中的内容，放入到一个CharArrayBuffer对象中，然后转换成String对象。

大致过程如下：

![e3b00680c2c078f759334c2ce38a2262.png][] image-20200826205852345

1.  DMA传输
2.  CPU传输，上下文切换
3.  CPU传输，上下文切换
4.  DMA传输

> “
> 
> DMA(Direct Memory Access 直接存储器读取)，\*\*即直接存储器存取，是一种快速传送数据的机制。\*\*DMA是指外部设备不通过CPU而直接与系统内存交换数据的接口技术。

第一步的DMA传输到Socket缓冲区，因为一切传输的底层都是socket，一个http请求必定是在服务的和客户端建立起socket连接，来发送请求。从网卡传输的数据被本地对应的socket接收，然后赋值给通过建立起相应的响应Response实例中的InputStream对象(打开一个可以传输socket中buffer数据的通道)，参考代码：

`org.apache.http.impl.io.SocketInputBuffer`的构造方法中：

public SocketInputBuffer(final Socket socket,int buffersize,final HttpParams params) throws IOException {
         
            super();
            if (socket == null) {
         
                throw new IllegalArgumentException("Socket may not be null");
            }
            this.socket = socket;
            this.eof = false;
            if (buffersize 0) {
         
                buffersize = socket.getReceiveBufferSize();
            }
            if (buffersize 1024) {
         
                buffersize = 1024;
            }
            init(socket.getInputStream(), buffersize, params);
        }

此方法被`org.apache.http.impl.SocketHttpServerConnection`调用，这个方法会初始化建立连接的流入流出通道：

protected void bind(final Socket socket, final HttpParams params) throws    IOException {
         
            if (socket == null) {
         
                throw new IllegalArgumentException("Socket may not be null");
            }
            if (params == null) {
         
                throw new IllegalArgumentException("HTTP parameters may not be null");
            }
            this.socket = socket;
    
            int buffersize = HttpConnectionParams.getSocketBufferSize(params);
    
            init(
                    createSessionInputBuffer(socket, buffersize, params),
                    createSessionOutputBuffer(socket, buffersize, params),
                    params);
    
            this.open = true;
        }

第二步的从socket缓冲区通过打开的stream读取数据，通过\`\`org.apache.http.util.EntityUtil.toString( final HttpEntity entity, final Charset defaultCharset)\`方法，读取到JVM中，在JVM中开辟一块内存。代码如下( 截取部分代码)：

final Reader reader = new InputStreamReader(instream, charset);
    final CharArrayBuffer buffer = new CharArrayBuffer(i);
    final char[] tmp = new char[1024];
    int l;
    while((l = reader.read(tmp)) != -1) {
         
        buffer.append(tmp, 0, l);
    }

用户拿到CharArrayBuffer就可以做后续相关操作了。

第三步的从用户态拷贝到直接内存，是通过`FileChannel`的方法`public abstract int write(ByteBuffer src) throws IOException;`来实现的，截取关键代码：

do {
         
        var3 = IOUtil.write(this.fd, var1, -1L, this.nd);
    } while(var3 == -3 && this.isOpen());
    
    int var5 = IOStatus.normalize(var3);
    return var5;

`IOUtil.write(this.fd, var1, -1L, this.nd);`

// 如果是直接内存，则不需要开辟直接内存
        if (var1 instanceof DirectBuffer) {
         
            return writeFromNativeBuffer(var0, var1, var2, var4);
        } else {
         
            int var5 = var1.position();
            int var6 = var1.limit();
            assert var5 <= var6;
            int var7 = var5 <= var6 ? var6 - var5 : 0;
          // 开辟一块直接内存
            ByteBuffer var8 = Util.getTemporaryDirectBuffer(var7);
            int var10;
            try {
         
                var8.put(var1);
                var8.flip();
                var1.position(var5);
                int var9 = writeFromNativeBuffer(var0, var8, var2, var4);
                if (var9 > 0) {
         
                    var1.position(var5 + var9);
                }

第四步是把内存中的直接内存中的数据写入到文件：

// 从直接内存的地址读取数据
              if (var2 != -1L) {
         
                    var9 = var4.pwrite(var0, ((DirectBuffer)var1).address() + (long)var5, var7, var2);
                } else {
         
                    var9 = var4.write(var0, ((DirectBuffer)var1).address() + (long)var5, var7);
                }

从上面的步骤可以看出几处冗余的步骤：

1.  数据多了三个副本，两个在内核内存中，一个在JVM中
2.  涉及两次CPU上下文切换，分别是从用户态切换到内核态，另一次是从内核态切换到用户态

# 2 零拷贝 #

我们是否可以舍弃数据与JVM的交互，直接从缓冲区写入到文件中呢？如下图所示：

![e029b504c9c22270bf37102b340a091b.png][] image-20200826222432254

1.  DMA拷贝
2.  DMA拷贝
3.  sendFile拷贝

特点：

1.  两次DMA拷贝
2.  无CPU状态切换
3.  数据减少了一次副本(如果源数据是DirectByteBuffer，是不需要读缓冲区的，相当于不需要创建额外的副本，如果源是FileInputChannel，可以使用Mmap，来减少副本个数)

从代码层面上看：

在`sun.nio.ch.FileChannelImpl`中有以下几个方法，调用了Linux的sendFile方法。

![4d3b5474a116efdd6276e29c45706963.png][] image-20200827084859292

随便找一个方法来看下`transferForm`:

public long transferFrom(ReadableByteChannel var1, long var2, long var4) throws IOException {
         
        this.ensureOpen();
        if (!var1.isOpen()) {
         
            throw new ClosedChannelException();
        } else if (!this.writable) {
         
            throw new NonWritableChannelException();
        } else if (var2 >= 0L && var4 >= 0L) {
         
            if (var2 > this.size()) {
         
                return 0L;
            } else {
         
              // 根据入参的channel是fileChannel还是普通的Channel，来调用不同的方法
                return var1 instanceof FileChannelImpl ? this.transferFromFileChannel((FileChannelImpl)var1, var2, var4) : this.transferFromArbitraryChannel(var1, var2, var4);
            }
        } else {
         
            throw new IllegalArgumentException();
        }
    }

*  如果是`FileChannel`， 则对File进行Mmaped，开辟一块直接内存，
    
     *      while(var11 > 0L) {
                     
                var15 = Math.min(var11, 8388608L);
                MappedByteBuffer var17 = var1.map(MapMode.READ_ONLY, var13, var15);
            
                try {
                     
                    long var18 = (long)this.write(var17, var2);
            
                    assert var18 > 0L;
            
                    var13 += var18;
                    var2 += var18;
                    var11 -= var18;
                } catch (IOException var25) {
                     
                    if (var11 != var9) {
                     
                        break;
                    }
            
                    throw var25;
                } finally {
                     
                    unmap(var17);
                }
            }
     *  然后通过`IOUtil.write`方法，进行数据的传输
 *  如果是普通的Channel，则会直接开辟一块直接内存，进行`IOUtil.write`
    
     *      private long transferFromArbitraryChannel(ReadableByteChannel var1, long var2, long var4) throws IOException {
                     
                int var6 = (int)Math.min(var4, 8192L);
                ByteBuffer var7 = Util.getTemporaryDirectBuffer(var6);
                long var8 = 0L;
                long var10 = var2;
            
                long var13;
                try {
                     
                    Util.erase(var7);
            
                    while(true) {
                     
                        if (var8                 var7.limit((int)Math.min(var4 - var8, 8192L));
                            int var12 = var1.read(var7);
                            if (var12 > 0) {
                     
                                var7.flip();
                                int var21 = this.write(var7, var10);
                                var8 += (long)var21;
                                if (var21 == var12) {
                     
                                    var10 += (long)var21;
                                    var7.clear();
                                    continue;
                                }
                            }
                        }
            
                        long var20 = var8;
                        return var20;
                    }
                } catch (IOException var18) {
                     
                    if (var8 <= 0L) {
                     
                        throw var18;
                    }
            
                    var13 = var8;
                } finally {
                     
                    Util.releaseTemporaryDirectBuffer(var7);
                }
            
                return var13;
            }

# 3 测试结果 #

<table> 
 <thead> 
  <tr> 
   <th>写入方式/请求数量</th> 
   <th>JVM参数</th> 
   <th>GC情况</th> 
   <th>JVM内存占用</th> 
   <th>CPU使用情况</th> 
   <th>耗时ms</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>常规方式写入/1000</td> 
   <td>-XX:+PrintGCDateStamps<br>-XX:+PrintGCDetails<br>-XX:+HeapDumpOnOutOfMemoryError<br>-XX:+UseGCLogFileRotation<br>-XX:NumberOfGCLogFiles=10<br>-XX:GCLogFileSize=10M<br>-XX:+PrintJNIGCStalls<br>-XX:MaxGCPauseMillis=200<br>-Xmx600M<br>-Xms600M<br>-verbose:gc<br>-XX:+UseG1GC</td> 
   <td><img src="https://img-blog.csdnimg.cn/img_convert/094e32bac6096573c1033d16b606a4d0.png" alt="094e32bac6096573c1033d16b606a4d0.png"></td> 
   <td>367.5M<img src="https://img-blog.csdnimg.cn/img_convert/26527249c61cadd6c5889cbde63c5c68.png" alt="26527249c61cadd6c5889cbde63c5c68.png"></td> 
   <td><img src="https://img-blog.csdnimg.cn/img_convert/cf828174118d5ddf721e33c18b7da269.png" alt="cf828174118d5ddf721e33c18b7da269.png"></td> 
   <td>109623</td> 
  </tr> 
  <tr> 
   <td>直接内存方式写入/1000</td> 
   <td>-XX:+PrintGCDateStamps<br>-XX:+PrintGCDetails<br>-XX:+HeapDumpOnOutOfMemoryError<br>-XX:+UseGCLogFileRotation<br>-XX:NumberOfGCLogFiles=10<br>-XX:GCLogFileSize=10M<br>-XX:+PrintJNIGCStalls<br>-XX:MaxGCPauseMillis=200<br>-Xmx600M<br>-Xms600M<br>-verbose:gc<br>-XX:+UseG1GC</td> 
   <td><img src="https://img-blog.csdnimg.cn/img_convert/f668de107939ee709f313cf04d227851.png" alt="f668de107939ee709f313cf04d227851.png"></td> 
   <td><img src="https://img-blog.csdnimg.cn/img_convert/6cd392aa65a0904da6d5fc294d236825.png" alt="6cd392aa65a0904da6d5fc294d236825.png"></td> 
   <td><img src="https://img-blog.csdnimg.cn/img_convert/da31021c0e1b6ccf58cc20c9be04c631.png" alt="da31021c0e1b6ccf58cc20c9be04c631.png"></td> 
   <td>109925</td> 
  </tr> 
 </tbody> 
</table>

图形中 Y 坐标表示消耗的时间(单位：秒)，X 坐标表示缓冲的大小(或运行次数，跳过了前三次运行)。

### FileChannel 和非直接模式 Buffer vs. FileChannel 和直接模式 Buffer ###

从下图看来，如果缓存小于 256KB，那么非直接模式的 Buffer 快一点，而缓存大于 256KB 后，直接模式的 Buffer 快一点：

![38c89e96f918a3f3ac9a3f58b2bfbcc6.png][] img

### FileChannel.transferTo() vs. FileChannel.transferFrom() vs. FileChannel.map() ###

从下图看来，FileChannel.transferTo() 和 FileChannel.transferFrom 运行七次的速度都差不多，而 FileChannel.map 的速度就要差很多：

![005b4019f3adff646b2432c713e88c21.png][] img

### 三种 Files.copy() 方法 ###

从下图看来，最快的是 Path 到 Path，其次是 Path 到 OutputStream，最慢的是 InputStream 到 Path：

![a5cd0ee4360eedb8cf6325e9825a46d1.png][] img

### FileChannel 和非直接模式 Buffer vs. FileChannel.transferTo() vs. Path 到 Path ###

最后，我们将前面最快的三种方式综合起来比较。从比较的结果来看，似乎 Path 到 Path 是最快的解决方案：

![9ef2c2d6f7a20a318e840ff44e623a86.png][] img

> “
> 
> MmappedByteBuffer：
> 
> **A direct byte buffer whose content is a memory-mapped region of a file.**
> 
> 其实就是把磁盘上的文件映射到内存中的一块区域，不需要把文件读入到JVM中，直接在内存中开辟一块共享区域，用户拿到内存地址来操作数据接口，免去了CPU状态切换和在JVM中开辟空间的操纵。
> 
> 示意图
> 
> ![8c0f39d950c014064c393b499ab59936.png][] image-20200827084236720

> “
> 
> 用户态和内核态的区别：
> 
> 内核态：cpu可以访问内存的所有数据，包括外围设备，例如硬盘，网卡，cpu也可以将自己从一个程序切换到另一个程序。
> 
> 用户态：只能受限的访问内存，且不允许访问外围设备，占用cpu的能力被剥夺，cpu资源可以被其他程序获取。
> 
> 所有用户程序都是运行在用户态的, 但是有时候程序确实需要做一些内核态的事情, 例如从硬盘读取数据, 或者从键盘获取输入等. 而唯一可以做这些事情的就是操作系统, 所以此时程序就需要先操作系统请求以程序的名义来执行这些操作.
> 
> 这时需要一个这样的机制: 用户态程序切换到内核态, 但是不能控制在内核态中执行的指令
> 
> 这种机制叫**系统调用**, 在CPU中的实现称之为**陷阱指令**(Trap Instruction)
> 
> 他们的工作流程如下:
> 
> 1.  用户态程序将一些数据值放在寄存器中, 或者使用参数创建一个堆栈(stack frame), 以此表明需要操作系统提供的服务.
> 2.  用户态程序执行陷阱指令
> 3.  CPU切换到内核态, 并跳到位于内存指定位置的指令, 这些指令是操作系统的一部分, 他们具有内存保护, 不可被用户态程序访问
> 4.  这些指令称之为陷阱(trap)或者系统调用处理器(system call handler). 他们会读取程序放入内存的数据参数, 并执行程序请求的服务
> 5.  系统调用完成后, 操作系统会重置CPU为用户态并返回系统调用的结果

参考文章：

1.  https://www.cnblogs.com/alantu2018/p/9140585.html
2.  http://imushan.com/2018/06/04/java/language/JDK%E6%BA%90%E7%A0%81%E9%98%85%E8%AF%BB-FileOutputStream/
3.  https://blog.csdn.net/youngyoungla/article/details/53106671
4.  https://blog.csdn.net/bestone0213/article/details/49093409

[e3b00680c2c078f759334c2ce38a2262.png]: /images/20221120/f61c52181a8641adac2f0bce2b8f6533.png
[e029b504c9c22270bf37102b340a091b.png]: /images/20221120/b8b6e69115e44354a26a7ab7e3b54bbe.png
[4d3b5474a116efdd6276e29c45706963.png]: /images/20221120/f0a09334343e4b5e9c7081599cd8fcec.png
[38c89e96f918a3f3ac9a3f58b2bfbcc6.png]: /images/20221120/48944c10de0647cf844420150971d198.png
[005b4019f3adff646b2432c713e88c21.png]: /images/20221120/f2b33a5c722147bca40c297abd7be6df.png
[a5cd0ee4360eedb8cf6325e9825a46d1.png]: /images/20221120/93b9d6a2c94f40a19f9daccacf9adfe4.png
[9ef2c2d6f7a20a318e840ff44e623a86.png]: /images/20221120/19cce0e064d84cab8c843702dfe881fe.png
[8c0f39d950c014064c393b499ab59936.png]: /images/20221120/be3b6a62d0c245eb843d145584af86e3.png