Java深入理解IO NIO在文件复制过程中的应用

最新推荐文章于 2024-10-03 15:04:14 发布
最新推荐文章于 2024-10-03 15:04:14 发布
阅读量9k 收藏 6
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skymouse2002/article/details/80567664
版权

 

第一种，传统的IO模式

	private static void copyByIO(String srcPath, String dstPath) {
        byte[] buffer = new byte[bufferSize];
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(srcPath);
            fos = new FileOutputStream(dstPath);
            int len;
            while ((len = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

第二种，NIO的 directbuffer模式

private static void copyByNIO(String srcPath, String dstPath) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        FileChannel fisChannel = null;
        FileChannel fosChannel = null;
        ByteBuffer buffer = ByteBuffer.allocateDirect(bufferSize);
        try {
            fis = new FileInputStream(srcPath);
            fos = new FileOutputStream(dstPath);
            fisChannel = fis.getChannel();
            fosChannel = fos.getChannel();
            while (fisChannel.read(buffer) != -1) {
                buffer.flip();
                fosChannel.write(buffer);
                buffer.clear();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fisChannel != null) {
                try {
                    fisChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fosChannel != null) {
                try {
                    fosChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

第3种，NIO transferto的模式

private static void copyByNIOTransfer(String srcPath, String dstPath) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        FileChannel fisChannel = null;
        FileChannel fosChannel = null;
        try {
            fis = new FileInputStream(srcPath);
            fos = new FileOutputStream(dstPath);
            fisChannel = fis.getChannel();
            fosChannel = fos.getChannel();
            long len = fisChannel.transferTo(0, fisChannel.size(), fosChannel);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fisChannel != null) {
                try {
                    fisChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fosChannel != null) {
                try {
                    fosChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

第4种，通过Files copy方式实现

private static void copyByFiles(String srcPath, String dstPath) {
        Path path = Paths.get(srcPath);
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(dstPath);
            /*
             * private static final int BUFFER_SIZE = 8192;
             * private static long copy(InputStream source, OutputStream sink) throws IOException
             * {
             * long nread = 0L;
             * byte[] buf = new byte[BUFFER_SIZE];
             * int n;
             * while ((n = source.read(buf)) > 0) {
             * sink.write(buf, 0, n);
             * nread += n;
             * }
             * return nread;
             * }
             */
            long len = Files.copy(path, fos);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
通过单个方法运行得出结果，IO最慢，Files.copy的速度接近transferto，但是查看源码疑惑出现了，下面列出源码Files.copy
createFile		000102400	cost	04342033631us
copyByIO		000102400	cost	254391101034132us
copyByNIO		000102400	cost	00241791703us
copyByNIOTransfer	000102400	cost	00178104807us
copyByFiles		000102400	cost	00202207341us

这是在另一台机械硬盘上的表现，第一台测试机带SSD，担心有影响，机械硬盘的结果比较明显了

5. FILE_SIZE = 102400 KB
createFile		000102400	cost	12997817696us
copyByIO		000102400	cost	00395415564us
copyByNIO		000102400	cost	00348269525us
copyByNIOTransfer	000102400	cost	00127312664us
copyByFiles		000102400	cost	00407214806us

 

 

这么看来感觉跟IO的实现一致啊，为什么速度差别那么大呢，继续跟代码，问题在图片1中newInputStream(source)方法中

这里提供的InputSteam实际上是sun.nio.ch.ChannelInputStream，而我们测试的IO中的InputSteam是用的FileInputSteam，而ch 实际是SeekableByteChannel ，由FileSystemProvider的实现类创建，而不同操作系统会提供不同的Prodvider，比如windows的差别就在这里了。

    public SeekableByteChannel newByteChannel(Path obj,
                                              Set<? extends OpenOption> options,
                                              FileAttribute<?>... attrs)
         throws IOException
    {
        WindowsPath file = WindowsPath.toWindowsPath(obj);
        WindowsSecurityDescriptor sd =
            WindowsSecurityDescriptor.fromAttribute(attrs);
        try {
            return WindowsChannelFactory
                .newFileChannel(file.getPathForWin32Calls(),
                                file.getPathForPermissionCheck(),
                                options,
                                sd.address());
        } catch (WindowsException x) {
            x.rethrowAsIOException(file);
            return null;  // keep compiler happy
        } finally {
            sd.release();
        }
    }

实际上Files.copy还有两种方式，一：

public static long copy(InputStream in, Path target, CopyOption... options)

关键在于

            ostream = newOutputStream(target, StandardOpenOption.CREATE_NEW,
                                              StandardOpenOption.WRITE);

从这里可用看出跟上面的方式基本一致，只不过一个是InputSteam，一个是OutStream。还有另外一种，二：方法如下

public static Path copy(Path source, Path target, CopyOption... options)

直接利用的是windows的复制功能

    @Override
    public void copy(Path source, Path target, CopyOption... options)
        throws IOException
    {
        WindowsFileCopy.copy(WindowsPath.toWindowsPath(source),
                             WindowsPath.toWindowsPath(target),
                             options);
    }

另外有一种方式与第二种方式类似，使用MappedByteBuffer来进行文件读写，底层是利用的mmap的机制

 

DMA(Direct Memory Access，直接内存存取) 是所有现代电脑的重要特色，它允许不同速度的硬件装置来沟通，而不需要依赖于 CPU 的大量中断负载。否则，CPU 需要从来源把每一片段的资料复制到暂存器，然后把它们再次写回到新的地方。在这个时间中，CPU 对于其他的工作来说就无法使用。

DMA 传输将数据从一个地址空间复制到另外一个地址空间。当CPU 初始化这个传输动作，传输动作本身是由 DMA 控制器来实行和完成。典型的例子就是移动一个外部内存的区块到芯片内部更快的内存区。像是这样的操作并没有让处理器工作拖延，反而可以被重新排程去处理其他的工作。DMA 传输对于高效能 嵌入式系统算法和网络是很重要的。

DMADMA

在实现DMA传输时，是由DMA控制器直接掌管总线，因此，存在着一个总线控制权转移问题。即DMA传输前，CPU要把总线控制权交给DMA控制器，而在结束DMA传输后，DMA控制器应立即把总线控制权再交回给CPU。一个完整的DMA传输过程必须经过DMA请求、DMA响应、DMA传输、DMA结束4个步骤。

DMA控制器与CPU怎样分时使用内存呢?通常采用以下三种方法：

(1)停止CPU访内存；

(2)周期挪用；

(3)DMA与CPU交替访问内存。

Linux高速缓冲区

高速缓冲区在整个物理内存中的位置处于内核区和主内存区之间,不在硬盘上，之前的理解有误跟swap区搞混了。

https://www.cnblogs.com/alantu2018/p/8447411.html

关于零拷贝的资料

https://www.jianshu.com/p/fad3339e3448 中文版

https://blog.csdn.net/hzrandd/article/details/51025341

https://blog.csdn.net/linsongbin1/article/details/77650105

https://blog.csdn.net/a417930422/article/details/52585862

https://www.linuxjournal.com/article/6345?page=0,2  e文版

https://www.ibm.com/developerworks/cn/java/j-zerocopy/#fig1

关于mmap的资料

https://blog.csdn.net/zqixiao_09/article/details/51088478

VM_IO将VMA设置成一个内存映射IO区域。

shm与mmap的区别联系

https://blog.csdn.net/bluenet13/article/details/40039497

Linux虚拟缓存

https://www.oschina.net/translate/understanding-virtual-memory

Linux IPC，FIFO和shm

https://blog.csdn.net/pouloghost/article/details/19997961

Linux IPC

https://blog.csdn.net/a987073381/article/details/52006729

 

https://www.cnblogs.com/wang_yb/p/3351599.html

http://blog.jqian.net/post/linux-shm.html

Linux文件Cache

https://www.ibm.com/developerworks/cn/linux/l-cache/

Linux文件系统预读

https://blog.csdn.net/AXW2013/article/details/55188316

Java中的IOStatus

static final int EOF = -1;              // End of file
static final int UNAVAILABLE = -2;      // Nothing available (non-blocking)
static final int INTERRUPTED = -3;      // System call interrupted
static final int UNSUPPORTED = -4;      // Operation not supported
static final int THROWN = -5;           // Exception thrown in JNI code
static final int UNSUPPORTED_CASE = -6; // This case not supported

 

Java io的读写情况，以

磁盘—>内核缓存—>native堆——>jvm heap——>native堆——>socket缓冲——>网卡

java多了native堆和jvm heap之间拷贝就是为了防止gc发生时jvm heap内部数据地址改变，导致读取错误数据。

directbuffer和c语言中的io速度一样的，是heapbuffer拖慢了性能，不是directbuffer提高了性能。

 

闭门车
关注
专栏目录
深入理解IO与NIO：Java中的IO模型
请 端正你的态度的博客
06-02 469
Java的传统IO和NIO在处理数据输入/输出时提供了不同的方法和模型。传统IO基于流和块，是阻塞式的，适用于简单的数据传输场景。而NIO则提供了更高效的非阻塞IO模型，通过通道、缓冲区和选择器等组件，能够处理大量并发连接，并提高了系统的性能和可扩展性。在选择使用哪种IO模型时，需要根据具体的应用场景和需求进行权衡。
NIO复制文件
02-15
利用NIO中的类进行开发的文件复制实例，学习下类的使用
JAVA功能代码《12》----使用NIO快速复制文件
web开发
05-21 336
12.使用NIO快速复制文件 public static void fileCopy(File in, File out) throws IOException { FileChannel inChannel = new FileInputStream(in).getChannel(); FileChannel outChannel = new FileOutputStream(ou...
【NIO基础】NIO（非阻塞 I/O）和 IO（传统 I/O）的区别，以及 NIO 的三大组件详解
最新发布
m0_65277261的博客
10-03 943
1、NIO是的缩写，意思就是“新型输入输出”，它是在 Java 1.4 版本里加进来的，中文可以叫“新 I/O”“非阻塞 I/O”。NIO 其实就是对传统的阻塞 IO 做了个加强版，专门为了解决以前处理大量数据或者很多并发连接时性能不够好的问题。NIO 的牛掰之处在于，它提供了：你可以发起 IO 操作而不用等着它完成，干别的事也行。：一个线程能管理好多个连接，不需要每个连接都分配一个线程。：NIO 用缓冲区来存数据，读写的时候可以灵活处理，不用一次性读完或写完。NIO 主要有三个。
Java New I/O的使用
starchu1981的专栏
11-13 2664
NIO的使用导读 J2SE1.4以上版本中发布了全新的I/O类库。本文将通过一些实例来简单介绍NIO库提供的一些新特性：非阻塞I/O，字符转换，缓冲以及通道。一. 介绍NIONIO包（java.nio.*）引入了四个关键的抽象数据类型，它们共同解决传统的I/O类中的一些问题。1． Buffer：它是包含数据且用于读写的线形表结构。其中还提供了一个特殊类用于内存映射文件的I/O操作。2． C
Nio进行文件复制
qq_41733238的博客
10-28 440
java使用nio的channel管道复制文件 package com.example.stream.nio; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.nio.channels.FileChannel; public class NioCopyFile {
JavaNIO实现文件复制
鱼的记忆
08-08 1159
NIO主要内容有Buffer、Channel、Charset及实现异步非阻塞IO的selector 这里通过使用IO流的getChannel()方法获取Channel，然后将文件内容映射到内存中获得Buffer 再将Buffer中的内容写入新的文件 package com.mark.learn.newio;import java.io.*; import java.nio.MappedByteBu
Java二进制IO类与文件复制操作实例.zip
08-28
在本实例中，我们将深入探讨Java中的二进制IO类以及如何执行文件复制操作。 首先，让我们了解Java中的二进制IO流。Java.io包提供了多种用于处理二进制数据的类，包括InputStream和OutputStream作为所有二进制输入和...
Java二进制IO类与文件复制操作实例
06-06
本篇文章将深入探讨Java中的二进制IO类，并通过一个具体的文件复制操作实例来说明其应用。 1. **Java IO流基础** Java的IO流模型基于“流”的概念，数据被当作一串连续的数据流进行处理。IO流分为两类：字节流...
NIO学习笔记（三）——NIO复制文件
qq1453186562的博客
08-13 471
前面我们已经学习了NIO的两大核心组件，channel和buffer。现在我们继续利用NIO来完成文件的复制操作。
Java NIO复制文件功能
^_^TaeYang-Jade^_^
02-03 527
1. package com.ghb.crp.file; 2. 3. import java.io.BufferedInputStream; 4. import java.io.BufferedOutputStream; 5. import java.io.File; 6. import java.io.FileInputStream; 7. imp
java nio 复制文件功能
ghb5371548的专栏
05-18 1897
  package com.ghb.crp.file;     import java.io.BufferedInputStream;   import java.io.BufferedOutputStream;   import java.io.File;   import java.io.FileInputStream;   import java.io.Fil
java nio实现文件复制
weixin_33753003的博客
03-25 104
public class TransferTo { public static void main(String[] args) throws Exception { FileChannel in = new FileInputStream("src/demo20/data.txt").getChannel(), out = new...
java nio 文件拷贝_Java通过NIO实现快速文件拷贝的代码
weixin_35671798的博客
02-16 174
将内容过程重要的内容片段做个记录，下面的内容段是关于Java通过NIO实现快速文件拷贝的内容。public static void fileCopy( File in, File out )throws IOException{FileChannel inChannel = new FileInputStream( in ).getChannel();FileChannel outChannel ...
java nio copy_Java NIO 实现文件复制
weixin_32762821的博客
02-24 101
/**int bytesRead=inChannel.read(buf);* 这句话是从文件流中读取一个buf内容，返回读取的大小，* 如果是读取到文件尾部的时候，返回的是-1** 注意FileChannel.write()是在while循环中调用的。* 因为无法保证write()方法一次能向FileChannel写入多少字节，* 因此需要重复调用write()方法，* 直到Buffer中已经没有...
java nio 拷贝文件
qq_23292875的博客
04-23 172
public static void main(String[] args) { try { FileChannel in = new FileInputStream("C:/Download/k8s.rar").getChannel(); FileChannel out = new FileOutputStream("C:/Download/k8s-nio.rar").getChannel(); // 连接两...
Java通过NIO实现快速文件拷贝的代码
weixin_34092370的博客
04-29 393
将内容过程重要的内容片段做个记录，下面的内容段是关于Java通过NIO实现快速文件拷贝的内容。 public static void fileCopy( File in, File out ) throws IOException { FileChannel inChannel = new FileInputStream( in ).getChannel...
深入理解Java NIO：非阻塞IO与Buffer详解
在实际应用中，学习和掌握Java NIO API需要理解Buffer的工作原理，如何正确设置其position、limit和mark，以及如何配合Channel和Selector进行高效的并发IO操作。同时，字符编码和解码也是必不可少的一部分，尤其是在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值