java-IO操作性能对比

在软件系统中，IO速度比内存速度慢，IO读写在很多情况下会是系统的瓶颈。

在java标准IO操作中，InputStream和OutputStream提供基于流的IO操作，以字节为处理单位；Reader和Writer实现了Buffered缓存，以字符为处理单位。

从Java1.4开始，增加NIO（New IO），增加缓存Buffer和通道Channel，以块为处理单位，是双向通道（可读可写，类似RandomAccessFile），支持锁和内存映射文件访问接口，大大提升了IO速度。

以下例子简单测试常见IO操作的性能速度。

1. /**
2. * 测试不同io操作速度
3. *
4. * @author peter_wang
5. * @create-time 2014-6-4 下午12:52:48
6. */
7. public class SpeedTest {
8. private static final String INPUT_FILE_PATH = "io_speed.txt";
9. private static final String OUTPUT_FILE_PATH = "io_speed_copy.txt";
10. /**
11. * @param args
12. */
13. public static void main(String[] args) {
14. long ioStreamTime1 = ioStreamCopy();
15. System.out.println("io stream copy:" + ioStreamTime1);
16. long ioStreamTime2 = bufferedStreamCopy();
17. System.out.println("buffered stream copy:" + ioStreamTime2);
18. long ioStreamTime3 = nioStreamCopy();
19. System.out.println("nio stream copy:" + ioStreamTime3);
20. long ioStreamTime4 = nioMemoryStreamCopy();
21. System.out.println("nio memory stream copy:" + ioStreamTime4);
22. }
23. /**
24. * 普通文件流读写
25. *
26. * @return 操作的时间
27. */
28. private static long ioStreamCopy() {
29. long costTime = -1;
30. FileInputStream is = null;
31. FileOutputStream os = null;
32. try {
33. long startTime = System.currentTimeMillis();
34. is = new FileInputStream(INPUT_FILE_PATH);
35. os = new FileOutputStream(OUTPUT_FILE_PATH);
36. int read = is.read();
37. while (read != -1) {
38. os.write(read);
39. read = is.read();
40. }
41. long endTime = System.currentTimeMillis();
42. costTime = endTime - startTime;
43. }
44. catch (FileNotFoundException e) {
45. e.printStackTrace();
46. }
47. catch (IOException e) {
48. e.printStackTrace();
49. }
50. finally {
51. try {
52. if (is != null) {
53. is.close();
54. }
55. if (os != null) {
56. os.close();
57. }
58. }
59. catch (IOException e) {
60. e.printStackTrace();
61. }
62. }
63. return costTime;
64. }
65. /**
66. * 加入缓存的文件流读写， Reader默认实现缓存，只能读取字符文件，无法准确读取字节文件如图片视频等
67. *
68. * @return 操作的时间
69. */
70. private static long bufferedStreamCopy() {
71. long costTime = -1;
72. FileReader reader = null;
73. FileWriter writer = null;
74. try {
75. long startTime = System.currentTimeMillis();
76. reader = new FileReader(INPUT_FILE_PATH);
77. writer = new FileWriter(OUTPUT_FILE_PATH);
78. int read = -1;
79. while ((read = reader.read()) != -1) {
80. writer.write(read);
81. }
82. writer.flush();
83. long endTime = System.currentTimeMillis();
84. costTime = endTime - startTime;
85. }
86. catch (FileNotFoundException e) {
87. e.printStackTrace();
88. }
89. catch (IOException e) {
90. e.printStackTrace();
91. }
92. finally {
93. try {
94. if (reader != null) {
95. reader.close();
96. }
97. if (writer != null) {
98. writer.close();
99. }
100. }
101. catch (IOException e) {
102. e.printStackTrace();
103. }
104. }
105. return costTime;
106. }
107. /**
108. * nio操作数据流
109. *
110. * @return 操作的时间
111. */
112. private static long nioStreamCopy() {
113. long costTime = -1;
114. FileInputStream is = null;
115. FileOutputStream os = null;
116. FileChannel fi = null;
117. FileChannel fo = null;
118. try {
119. long startTime = System.currentTimeMillis();
120. is = new FileInputStream(INPUT_FILE_PATH);
121. os = new FileOutputStream(OUTPUT_FILE_PATH);
122. fi = is.getChannel();
123. fo = os.getChannel();
124. ByteBuffer buffer = ByteBuffer.allocate(1024);
125. while (true) {
126. buffer.clear();
127. int read = fi.read(buffer);
128. if (read == -1) {
129. break;
130. }
131. buffer.flip();
132. fo.write(buffer);
133. }
134. long endTime = System.currentTimeMillis();
135. costTime = endTime - startTime;
136. }
137. catch (FileNotFoundException e) {
138. e.printStackTrace();
139. }
140. catch (IOException e) {
141. e.printStackTrace();
142. }
143. finally {
144. try {
145. if (fi != null) {
146. fi.close();
147. }
148. if (fo != null) {
149. fo.close();
150. }
151. if (is != null) {
152. is.close();
153. }
154. if (os != null) {
155. os.close();
156. }
157. }
158. catch (IOException e) {
159. e.printStackTrace();
160. }
161. }
162. return costTime;
163. }
164. /**
165. * nio内存映射操作数据流
166. *
167. * @return 操作的时间
168. */
169. private static long nioMemoryStreamCopy() {
170. long costTime = -1;
171. FileInputStream is = null;
172. //映射文件输出必须用RandomAccessFile
173. RandomAccessFile os = null;
174. FileChannel fi = null;
175. FileChannel fo = null;
176. try {
177. long startTime = System.currentTimeMillis();
178. is = new FileInputStream(INPUT_FILE_PATH);
179. os = new RandomAccessFile(OUTPUT_FILE_PATH, "rw");
180. fi = is.getChannel();
181. fo = os.getChannel();
182. IntBuffer iIb=fi.map(FileChannel.MapMode.READ_ONLY, 0, fi.size()).asIntBuffer();
183. IntBuffer oIb = fo.map(FileChannel.MapMode.READ_WRITE, 0, fo.size()).asIntBuffer();
184. while(iIb.hasRemaining()){
185. int read = iIb.get();
186. oIb.put(read);
187. }
188. long endTime = System.currentTimeMillis();
189. costTime = endTime - startTime;
190. }
191. catch (FileNotFoundException e) {
192. e.printStackTrace();
193. }
194. catch (IOException e) {
195. e.printStackTrace();
196. }
197. finally {
198. try {
199. if (fi != null) {
200. fi.close();
201. }
202. if (fo != null) {
203. fo.close();
204. }
205. if (is != null) {
206. is.close();
207. }
208. if (os != null) {
209. os.close();
210. }
211. }
212. catch (IOException e) {
213. e.printStackTrace();
214. }
215. }
216. return costTime;
217. }
218. }

运行结果：

1. io stream copy:384
2. buffered stream copy:125
3. nio stream copy:12
4. nio memory stream copy:10

结论分析：

最普通的InputStream操作耗时较长，增加了缓存后速度增加了，用了nio和内存映射访问文件，速度最快。