文件拷贝， 使用 BIO,NIO的对比，四种写法性能分析。

最新推荐文章于 2021-02-25 21:46:49 发布
最新推荐文章于 2021-02-25 21:46:49 发布
阅读量110 收藏
点赞数
原文链接：http://www.cnblogs.com/personnel/p/4584919.html
版权

测试环境： jdk 1.7 +  2G内存

测试代码基本上复制了： http://blog.csdn.net/tabactivity/article/details/9317143

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
package  test;
 
import  java.io.BufferedInputStream;
import  java.io.BufferedOutputStream;
import  java.io.File;
 
import  java.io.FileInputStream;
 
import  java.io.FileOutputStream;
 
import  java.nio.MappedByteBuffer;
 
import  java.nio.channels.FileChannel;
 
public  class  FileCopyTest
{
 
     public  FileCopyTest()
     {
         File[] files =  new  File( "c:/images" ).listFiles();
         String destFolderPath =  "g:/images" ;
 
         long  t = System.currentTimeMillis();
 
         try
         {
             for  (File sourceFile : files)
             {
                 traditionalCopy(sourceFile.getPath(), destFolderPath +  "/"  + sourceFile.getName());
             }
 
         }
         catch  (Exception e)
         {
             e.printStackTrace();
         }
         System.out.println( "传统IO方法实现文件拷贝耗时:"  + (System.currentTimeMillis() - t) +  "ms" );
 
         //删除刚刚创建的
         for  (File file :  new  File(destFolderPath).listFiles())
         {
             file.delete();
         }
 
         t = System.currentTimeMillis();
         try
         {
             for  (File sourceFile : files)
             {
                 copyBIO(sourceFile.getPath(), destFolderPath +  "/"  + sourceFile.getName());
             }
 
         }
         catch  (Exception e)
         {
             e.printStackTrace();
         }
         System.out.println( "传统IO + 缓存 方法实现文件拷贝耗时:"  + (System.currentTimeMillis() - t) +  "ms" );
 
         //删除刚刚创建的
         for  (File file :  new  File(destFolderPath).listFiles())
         {
             file.delete();
         }
 
         t = System.currentTimeMillis();
         try
         {
             for  (File sourceFile : files)
             {
                 nioCopy(sourceFile.getPath(), destFolderPath +  "/"  + sourceFile.getName());
             }
         }
         catch  (Exception e)
         {
             e.printStackTrace();
         }
         System.out.println( "利用NIO文件通道方法实现文件拷贝耗时:"  + (System.currentTimeMillis() - t) +  "ms" );
 
         //删除刚刚创建的
         for  (File file :  new  File(destFolderPath).listFiles())
         {
             file.delete();
         }
 
         t = System.currentTimeMillis();
         try
         {
             for  (File sourceFile : files)
             {
                 nioCopy2(sourceFile.getPath(), destFolderPath +  "/"  + sourceFile.getName());
             }
         }
         catch  (Exception e)
         {
             e.printStackTrace();
         }
         System.out.println( "利用NIO文件内存映射及文件通道实现文件拷贝耗时:"  + (System.currentTimeMillis() - t) +  "ms" );
 
         //删除刚刚创建的
         for  (File file :  new  File(destFolderPath).listFiles())
         {
             file.delete();
         }
 
     }
 
     private  static  void  traditionalCopy(String sourcePath, String destPath)  throws  Exception
     {
         File source =  new  File(sourcePath);
         File dest =  new  File(destPath);
 
         FileInputStream fis =  new  FileInputStream(source);
         FileOutputStream fos =  new  FileOutputStream(dest);
         
         byte [] buf =  new  byte [ 8192 ];
         int  len =  0 ;
 
         while  ((len = fis.read(buf)) != - 1 )
         {
             fos.write(buf,  0 , len);
         }
 
         fis.close();
         fos.close();
     }
 
     private  static  void  copyBIO(String sourcePath, String destPath)  throws  Exception
     {
         File source =  new  File(sourcePath);
         File dest =  new  File(destPath);
 
         BufferedInputStream bis =  new  BufferedInputStream( new  FileInputStream(source));
         BufferedOutputStream bos =  new  BufferedOutputStream( new  FileOutputStream(dest));
 
         byte [] buf =  new  byte [ 8192 ];
         int  len =  0 ;
         while  ((len = bis.read(buf)) != - 1 )
         {
             bos.write(buf,  0 , len);
         }
 
         bis.close();
         bos.close();
     }
 
     private  static  void  nioCopy(String sourcePath, String destPath)  throws  Exception
     {
         File source =  new  File(sourcePath);
         File dest =  new  File(destPath);
 
         FileInputStream fis =  new  FileInputStream(source);
         FileOutputStream fos =  new  FileOutputStream(dest);
 
         FileChannel sourceCh = fis.getChannel();
         FileChannel destCh = fos.getChannel();
 
         destCh.transferFrom(sourceCh,  0 , sourceCh.size());
 
         sourceCh.close();
         destCh.close();
 
     }
 
     private  static  void  nioCopy2(String sourcePath, String destPath)  throws  Exception
     {
         File source =  new  File(sourcePath);
         File dest =  new  File(destPath);
 
         FileInputStream fis =  new  FileInputStream(source);
         FileOutputStream fos =  new  FileOutputStream(dest);
 
         FileChannel sourceCh = fis.getChannel();
         FileChannel destCh = fos.getChannel();
 
         MappedByteBuffer mbb = sourceCh.map(FileChannel.MapMode.READ_ONLY,  0 , sourceCh.size());
 
         destCh.write(mbb);
 
         sourceCh.close();
         destCh.close();
     }
 
}

 

 

测试结果有些地方还是感到意外：

 

复制到同一块硬盘的其他分区, 总文件大小： 33M,其中一个文件：16M

-----------------------------------------------------------------------------

传统IO方法实现文件拷贝耗时:1156ms

传统IO + 缓存 方法实现文件拷贝耗时:1312ms

利用NIO文件通道方法实现文件拷贝耗时:1109ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:891ms

 

传统IO方法实现文件拷贝耗时:1157ms

传统IO + 缓存 方法实现文件拷贝耗时:1312ms

利用NIO文件通道方法实现文件拷贝耗时:1078ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:891ms

 

传统IO方法实现文件拷贝耗时:1203ms

传统IO + 缓存 方法实现文件拷贝耗时:1172ms

利用NIO文件通道方法实现文件拷贝耗时:1157ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:891ms

 

传统IO方法实现文件拷贝耗时:984ms

传统IO + 缓存 方法实现文件拷贝耗时:984ms

利用NIO文件通道方法实现文件拷贝耗时:1172ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:938ms

 

 

 

复制到另一个硬盘, 总文件大小： 33M,其中一个文件：16M

-----------------------------------------------------------------------------

传统IO方法实现文件拷贝耗时:1110ms

传统IO + 缓存 方法实现文件拷贝耗时:1343ms

利用NIO文件通道方法实现文件拷贝耗时:984ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:937ms

 

传统IO方法实现文件拷贝耗时:985ms

传统IO + 缓存 方法实现文件拷贝耗时:1516ms

利用NIO文件通道方法实现文件拷贝耗时:1203ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:890ms

 

传统IO方法实现文件拷贝耗时:875ms

传统IO + 缓存 方法实现文件拷贝耗时:1203ms

利用NIO文件通道方法实现文件拷贝耗时:1391ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:1031ms

 

传统IO方法实现文件拷贝耗时:938ms

传统IO + 缓存 方法实现文件拷贝耗时:1266ms

利用NIO文件通道方法实现文件拷贝耗时:1453ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:968ms

 

 

 

复制到另一个硬盘, 总文件大小： 81M,其中一个文件：66M

-----------------------------------------------------------------------------

传统IO方法实现文件拷贝耗时:4812ms

传统IO + 缓存 方法实现文件拷贝耗时:6250ms

利用NIO文件通道方法实现文件拷贝耗时:3375ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:3453ms

 

传统IO方法实现文件拷贝耗时:5328ms

传统IO + 缓存 方法实现文件拷贝耗时:6110ms

利用NIO文件通道方法实现文件拷贝耗时:3766ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:3641ms

 

 

 

复制到移动硬盘(用了3年), 总文件大小： 33M,其中一个文件：16M

-----------------------------------------------------------------------------

传统IO方法实现文件拷贝耗时:16532ms

传统IO + 缓存 方法实现文件拷贝耗时:15828ms

利用NIO文件通道方法实现文件拷贝耗时:34437ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:34797ms

 

传统IO方法实现文件拷贝耗时:20672ms

传统IO + 缓存 方法实现文件拷贝耗时:19547ms

利用NIO文件通道方法实现文件拷贝耗时:33844ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:33375ms

 

 

 

复制到移动硬盘(用了3年), 总文件大小： 15M,单个文件：150KB左右。

-----------------------------------------------------------------------------

传统IO方法实现文件拷贝耗时:172ms

传统IO + 缓存 方法实现文件拷贝耗时:157ms

利用NIO文件通道方法实现文件拷贝耗时:188ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:313ms

 

传统IO方法实现文件拷贝耗时:156ms

传统IO + 缓存 方法实现文件拷贝耗时:156ms

利用NIO文件通道方法实现文件拷贝耗时:188ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:344ms

 

传统IO方法实现文件拷贝耗时:203ms

传统IO + 缓存 方法实现文件拷贝耗时:218ms

利用NIO文件通道方法实现文件拷贝耗时:187ms

利用NIO文件内存映射及文件通道实现文件拷贝耗时:282ms

 

 

总结：

1. 根据上面的测试结果表明，如果拷贝的是小文件(单个文件几百KB)，使用NIO并不会比IO快.

如果拷贝的单个文件达到几十M+，使用NIO速度会快的比较明显。

 

2. 测试时还发现 traditionalCopy()无论处理小文件还是大文件都不比copyBIO()慢。

traditionalCopy()就是使用最基本的 FileInputStream 和 FileOutStream。

copyBIO()使用的是BufferedInputStream 和 BufferedOutputStream。

关于这一点，可能是因为 “从1.5开始，Java对InputStream/OutputStream 进行了重新改写，用的就是NIO，因此，就算你不显示声明要用NIO，只要你的类继承了InputStream/OutputStream就已经在用NIO了”

参考资料： http://zhidao.baidu.com/question/109313742.html

 

3. 测试拷贝到移动硬盘上时，使用传统的IO比NIO速度还快，并且快很多。（这块移动硬盘用了3年，写入速度不怎么样）

这个原因我无法解释，有谁能告诉我？

 

2014-03-02

转载于:https://www.cnblogs.com/personnel/p/4584919.html

weixin_30509393
关注
Java NIO？看这一篇就够了！
07-19 118
https://blog.csdn.net/u011381576/article/details/79876754 &n...
这个疯子整理的十万字Java面试题汇总，终于拿下40W offer！（JDK源码+微服务合集+并发编程+性能优化合集+
m0_67401134的博客
07-23 2434
Spring框架是一个为Java应用程序的开发提供了综合、广泛的基础性支持的Java平台。Spring帮助开发者解决了开发中基础性的问题,使得开发人员可以专注于应用程序的开发。Spring框架本身亦是按照设计模式精心打造,这使得我们可以在开发环境中安心的集成Spring框架,不必担心Spring是如何在后台进行工作的。Spring框架至今已集成了20多个模块。这些模块主要被分如下图所示的核心容器、数据访问/集成,、Web、AOP(面向切面编程)、工具、消息和测试模块。...
java中的nio和bio速度对比_Java使用BIO和NIO进行文件操作比较
weixin_31360095的博客
02-25 261
packagecom.zhi.test;importjava.io.FileInputStream;importjava.io.FileReader;importjava.io.IOException;importjava.nio.ByteBuffer;importjava.nio.CharBuffer;importjava.nio.channels.FileChannel;importjava....
使用NIO与BIO复制文件性能对比
is_zhoufeng的专栏
05-12 1610
package mr.mr03; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import org.junit.Test; publi
BIO与NIO读写文件对比
qq_34857390的博客
07-24 524
1. BIO: blocking input/output 同步阻塞 public static void fileTest() throws Exception { FileWriter fileWriter = new FileWriter(filePath, true); fileWriter.write("nihao"); fileW...
java读写文件时nio、bio对比
赶路人儿
04-15 2739
1.   基本 概念       IO 是主存和外部设备 ( 硬盘、终端和网络等 ) 拷贝数据的过程。 IO 是操作系统的底层功能实现，底层通过 I/O 指令进行完成。 所有语言运行时系统提供执行 I/O 较高级别的工具。 (c 的 printf scanf,java 的面向对象封装 )  2.    Java 标准 io 回顾        Java 标准 IO 类库是 io 面向
分别使用BIO和NIO来实现文件的拷贝并比较两者的效率
dms2017的博客
04-29 791
1. 本期竞争者有四位，分别是： 第一位：FileInputStream+FileOutputStream（BIO）； 第二位：BufferedFileInputStream+BufferedFileOutputStream（BIO）； 第三位：ByteBuffer+Channel（NIO）； 第四位：MappedByteBuffer+Channel（NIO）； 2. 分别实现文件拷...
Java高性能：干货分享——让你快速掌握《NIO》
weixin_44829998的博客
06-27 271
一、概述 NIO主要有三大核心部分：Channel(通道)、Buffer(缓冲区)、 Selector。 NIO和传统IO（一下简称IO）之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需...
NIO相关基础篇二
最简单的东西，往往包含了最复杂的实现。
12-19 837
转载请注明原创出处，谢谢！ 上篇NIO相关基础篇一，主要介绍了一些基本的概念以及缓冲区（Buffer）和通道（Channel），本篇继续NIO相关话题内容，主要就是文件锁、以及比较关键的Selector，后续还会继续有一到二篇左右与NIO内容相关。文件锁（FileLock） 在看RocketMQ源码中，发现有关于文件锁的import，但是具体使用代码里面注释调了[回头看看为什么，理解下，到时候会
Netty的流程和范例（自主拼凑研发）
kdy527的专栏
11-16 3644
Netty的流程和范例（自主拼凑研发）   一，netty的原理 1.要了解netty，就要了解一下三个概念：nio,bio,aio Bio:同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器就需要启动一个线程进行处理，如果这个连接不做任何事情就会造成不必要的线程开销，当然可以通过线程池机制改善。它适用于连接数目小的框架，B和流量很高的应用，如文件传输。 例： I
NIO和阻塞io的读写文件效率差异
beagreatprogrammer的专栏
04-12 3198
最近因为准备好好学学Netty，在看nio的东西，据说NIO比io的效率快很多，决定写个小程序试试，下面是代码： import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.nio.ByteBuffer;
为什么NIO比BIO效率高
热门推荐
阿肯那顿的博客
02-26 1万+
NIO比BIO效率高，主要原因是什么呢？ 网上大多给出了两者的区别，可是具体效率高在哪里呢。 首先我们看一下各自的特点 BIO： socketServer的accept方法是阻塞的。 当有连接请求时，socketServer通过accept方法获取一个socket 取得socket后，将这个socket分给一个线程去处理。此时socket需要等待有效的请求数据到来后，才可以真正开始处理请...
NIO与普通IO文件读写性能对比
qq_44925357的博客
04-21 972
NIO与普通IO文件读写性能对比
谈谈我对java的BIO和NIO的学习的理解
studentchen的博客
10-11 1285
首先io是人机交互的前提 是非常重要滴 java在早期只有bio 后面更新出来了nio nio的作用越来越重要 有的人称nio为阻塞式io 这点我觉得很不严谨 而且对于阻塞与非阻塞的概念我看很多人的说法也不一致 在此我只说说我自己的认识 毕竟认知也是一个不断提升和完善的过程 就像地球由方到圆一样   io又分为磁盘io 和网络io   首先传统io是"单个"  nio是"多个" 从...
java网络编程_Java网络编程与NIO详解8：浅析mmap和Direct Buffer
weixin_39560657的博客
11-14 146
本文转自：https://www.cnblogs.com/huxiao-tee/p/4660352.html本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看https://github.com/h2pl/Java-Tutorial喜欢的话麻烦点下Star哈文章将同步到我的个人博客：http://www.how2playlife.com本文是微信公众号【...
转BIO，NIO和AIO讲的很明白的文章
lengyue309的博客
10-31 3780
到底什么是“IO Block” 很多人说BIO不好，会“block”，但到底什么是IO的Block呢？考虑下面两种情况： 用系统调用read从socket里读取一段数据 用系统调用read从一个磁盘文件读取一段数据到内存 如果你的直觉告诉你，这两种都算“Block”，那么很遗憾，你的理解与Linux不同。Linux认为： 对于第一种情况，算作block，因为Linux无法知道网络上对方...
Java BIO与NIO的比较
Lisam Blog
09-02 7232
前提：相对于传统IO，NIO将磁盘->内核空间缓冲区->用户空间缓冲区变为                                              磁盘->用户空间缓冲区  ，减少了中间的拷贝过程。   BIO读取过程： 读取过程(共三次复制拷贝过程)： 1 jvm堆执行fileInputStream.read()请求操作系统，然后操作系统请求磁盘。 ...
BIO与NIO的方式实现文件拷贝
XYC3939的博客
11-14 169
面试题 - 编程实现文件拷贝。（这个题目在笔试的时候经常出现，下面的代码给出了两种实现方案） import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import ...
nio和io拷贝文件性能对比
weixin_30287169的博客
01-27 216
代码如下： 1 package my; 2 3 import java.io.BufferedInputStream; 4 import java.io.BufferedOutputStream; 5 import java.io.BufferedReader; 6 import java.io.BufferedWriter; 7 impo...
Java BIO与NIO文件操作对比详解及代码实例
本文档详细探讨了Java中基于BIO (Blocking I/O) 和 NIO (Non-Blocking I/O) 的文件操作方法，并通过代码示例对比它们的性能和工作方式。首先，让我们理解什么是Java NIO。 Java NIO（New I/O）是一种改进的I/O模型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值