IO性能分析.docx

1、IO性能分析IO性能分析本文大多技术围绕调整磁盘文件 I/O,但是有些内容也同样适合网络 I/O 和窗口输出。第一部分技术讨论底层的I/O问题，然后讨论诸如压缩，格式化和串行化等高级I/O问题。然而这个讨论没有包含应用设计问题，例如搜索算法和数据结构，也没有讨论系统级的问题，例如文件高速缓冲。 Java语言采取两种截然不同的磁盘文件结构。一个是基于字节流，另一个是字符序列。在Java 语言中一个字符有两个字节表示，而不是像通常的语言如c语言那样是一个字节。因此，从一个文件读取字符时需要进行转换。这个不同在某些情况下是很重要的， 就像下面的几个例子将要展示的那样。 低级I/O相关的问题： 缓冲

2、读写文本文件 格式化的代价 随机访问 高级I/O问题 压缩 高速缓冲 分解 串行化 获取文件信息 更多信息 加速I/O的基本规则 避免访问磁盘 避免访问底层的操作系统 避免方法调用 避免个别的处理字节和字符 很明显这些规则不能在所有的问题上避免，因为如果能够的话就没有实际的I/O被执行。使用缓存减少读写次数开销 使用缓冲加速文件读取的示例：对于一个1 MB的输入文件，以秒为单位的执行时间是: FileInputStream的read方法，每次读取一个字节，不用缓冲 6.9秒 BufferedInputStream的read方法使用BufferedInputStream 0.9秒 FileInp

3、utStream的read方法读取数据到直接缓冲 0.4秒 或者说在最慢的方法和最快的方法间是17比1的不同。 这个巨大的加速并不能证明你应该总是使用第三种方法，即自己做缓冲。这可能是一个错误的倾向特别是在处理文件结束事件时没有仔细的实现。在可读性上它也没有其它方法好。但是记住时间花费在哪儿了以及在必要的时候如何矫正是很有用。方法2 或许是对于大多应用的 正确 方法. 方法 2 和 3 使用了缓冲技术, 大块文件被从磁盘读取，然后每次访问一个字节或字符。缓冲是一个基本而重要的加速I/O 的技术,而且有几个类支持缓冲(BufferedInputStream 用于字节, BufferedReade

4、r 用于字符)。 缓冲区越大I/O越快吗？典型的Java缓冲区长1024 或者 2048 字节，一个更大的缓冲区有可能加速 I/O但比重很小，大约5 到10%。 方法1: 读方法第一个方法简单的使用FileInputStream的read方法: FileInputStream的read方法每次读取文件的下一个字节，触发了大量的底层运行时系统调用优点：编码简单，适用于小文件缺点：读写频繁，不适用于大文件import java.io.*; public class intro1 public static void main(String args) if (args.length != 1) S

5、ystem.err.println(missing filename); System.exit(1); try FileInputStream fis = new FileInputStream(args0); / 建立指向文件的读写流 int cnt = 0; int b; while (b = fis.read() != -1 ) / FileInputStream 的read方法每次 读取文件一个字节 if (b = n) cnt+; fis.close(); System.out.println(cnt); catch (IOException e) System.err.print

6、ln(e); 方法 2: 使用大缓冲区第二种方法使用大缓冲区避免了上面的问题: BufferedInputStream的read方法 把文件的字节块读入缓冲区，然后每次读取一个字节，每次填充缓冲只需要访问一次底层存储接口优点：避免每个字节的底层读取，编码相对不复杂缺点：缓存占用了小量内存import java.io.*;public class intro2 public static void main(String args) if (args.length != 1) System.err.println(missing filename); System.exit(1); try Fi

7、leInputStream fis = new FileInputStream(args0); BufferedInputStream bis = new BufferedInputStream(fis); / 把文件读取流指向缓冲区 int cnt = 0; int b; while (b = bis.read() != -1 ) /BufferedInputStream 的read方法 把文件的字节块独 /入缓冲区BufferedInputStream，然后每次读取一个字节 if (b = n) cnt+; bis.close(); System.out.println(cnt); cat

8、ch (IOException e) System.err.println(e); 方法 3: 直接缓冲FileInputStream的read方法直接读入字节块到直接缓冲buf，然后每次读取一个字节。优点：速度最快，缺点：编码稍微复杂，可读性差，占用了小量内存，import java.io.*; public class intro3 public static void main(String args) if (args.length != 1) System.err.println(missing filename); System.exit(1); try FileInputStre

9、am fis = new FileInputStream(args0); byte buf = new byte2048; int cnt = 0; int n; while (n = fis.read(buf) != -1 ) / FileInputStream 的read方法直接读入字节块到 /直接缓冲buf，然后每次读取一个字节 for (int i = 0; i n; i+) if (bufi = n) cnt+; fis.close(); System.out.println(cnt); catch (IOException e) System.err.println(e); 方法4

10、: 缓冲整个文件缓冲的极端情况是事先决定整个文件的长度，然后读取整个文件。优点：把文件底层读取降到最少，一次，缺点：大文件会耗尽内存。import java.io.*; public class readfile public static void main(String args) if (args.length != 1) System.err.println(missing filename); System.exit(1); try int len = (int)(new File(args0).length(); FileInputStream fis = new FileInpu

11、tStream(args0); byte buf = new bytelen; /建立直接缓冲 fis.read(buf); / 读取整个文件 fis.close(); int cnt = 0; for (int i = 0; i len; i+) if (bufi = n) cnt+; System.out.println(cnt); catch (IOException e) System.err.println(e); 这个方法很方便，在这里文件被当作一个字节数组。但是有一个明显得问题是有可能没有读取一个巨大的文件的足够的内存。 缓冲的另一个方面是向窗口终端的文本输出。缺省情况下， Sy

12、stem.out ( 一个PrintStream) 是行缓冲的，这意味着在遇到一个新行符后输出缓冲区被提交。格式化的代价 实际上向文件写数据只是输出代价的一部分。另一个可观的代价是数据格式化。考虑下面的字符输出程序性能对比结果为：这些程序产生同样的输出。运行时间是: 格式化方法示例语句运行时间简单的输出一个固定字符System.out.print(s);1.3秒使用简单格式+String s = 字符+字符， System.out.print(s);1.8秒使用java.text包中的 MessageFormat 类的对象方法String s = fmt.format(values);Syst

13、em.out.print(s);7.8秒使用java.text包中的 MessageFormat 类的静态方法7.8*1.3秒最慢的和最快的大约是6比1。如果格式没有预编译第三种方法将更慢，使用静态的方法代替: 第三个方法比前两种方法慢很多的事实并不意味着你不应该使用它，而是你要意识到时间上的开销。 在国际化的情况下信息格式化是很重要的，关心这个问题的应用程序通常从一个绑定的资源中读取格式然后使用它。 方法 1，简单的输出一个固定的字符串，了解固有的I/O开销: public class format1 public static void main(String args) final in

14、t COUNT = 25000; for (int i = 1; i = COUNT; i+) String s = The square of 5 is 25n; System.out.print(s); 方法2，使用简单格式+: public class format2 public static void main(String args) int n = 5; final int COUNT = 25000; for (int i = 1; i = COUNT; i+) String s = The square of + n + is + n * n + n; System.out.

15、print(s); 方法 3，第三种方法使用java.text包中的 MessageFormat 类的对象方法: import java.text.*;public class format3 public static void main(String args) MessageFormat fmt = new MessageFormat(The square of 0 is 1n); Object values = new Object2; int n = 5; values0 = new Integer(n); values1 = new Integer(n * n); final in

16、t COUNT = 25000; for (int i = 1; i = COUNT; i+) String s = fmt.format(values); System.out.print(s); 方法 4，使用MessageFormat.format(String, Object) 类的静态方法import java.text.*; public class format4 public static void main(String args) String fmt = The square of 0 is 1n; Object values = new Object2; int n =

17、 5; values0 = new Integer(n); values1 = new Integer(n * n); final int COUNT = 25000; for (int i = 1; i = 0）。这样的一个例子是:这个程序简单的读取字节序列然后输出它们。 适用的情况：如果有访问位置，这个技术是很有用的，文件中的附近字节几乎在同时被读取。例如，如果你在一个排序的文件上实现二分法查找，这个方法可能很有用。不适用的情况：如果你在一个巨大的文件上的任意点做随机访问的话就没有太大价值。import java.io.*; public class ReadRandom private

18、static final int DEFAULT_BUFSIZE = 4096; private RandomAccessFile raf; private byte inbuf; private long startpos = -1; private long endpos = -1; private int bufsize; public ReadRandom(String name) throws FileNotFoundException this(name, DEFAULT_BUFSIZE); public ReadRandom(String name, int b) throws

19、FileNotFoundException raf = new RandomAccessFile(name, r); bufsize = b; inbuf = new bytebufsize; public int read(long pos) if (pos endpos) long blockstart = (pos / bufsize) * bufsize; int n; try raf.seek(blockstart); n = raf.read(inbuf); catch (IOException e) return -1; startpos = blockstart; endpos

20、 = blockstart + n - 1; if (pos endpos) return -1; return inbuf(int)(pos - startpos) & 0xffff; public void close() throws IOException raf.close(); public static void main(String args) if (args.length != 1) System.err.println(missing filename); System.exit(1); try ReadRandom rr = new ReadRandom(args0)

21、; long pos = 0; int c; byte buf = new byte1; while (c = rr.read(pos) != -1) pos+; buf0 = (byte)c; System.out.write(buf, 0, 1); rr.close(); catch (IOException e) System.err.println(e); 压缩的性能开销 Java提供用于压缩和解压字节流的类，这些类包含在java.util.zip 包里面，这些类也作为 Jar 文件的服务基础 ( Jar 文件是带有附加文件列表的 Zip 文件)。 压缩的目的是减少存储空间，同时被压缩

22、的文件在IO速度不变的情况下会减少传输时间。压缩时候要消耗CPU时间，占用内存。压缩时间=数据量/压缩速度。IO传输时间=数据容量/ IO速度。传输数据的总时间压缩时间I/O传输时间压缩是提高还是损害I/O性能很大程度依赖你的硬件配置，特别是和处理器和磁盘驱动器的速度相关。使用Zip技术的压缩通常意味着在数据大小上减少50%，但是代价是压缩和解压的时间。一个巨大(5到10 MB)的压缩文本文件，使用带有IDE硬盘驱动器的300-MHz Pentium PC从硬盘上读取可以比不压缩少用大约1/3的时间。 压缩的一个有用的范例是向非常慢的媒介例如软盘写数据。使用高速处理器(300 MHz Pent

23、ium)和低速软驱(PC上的普通软驱)的一个测试显示压缩一个巨大的文本文件然后在写入软盘比直接写入软盘快大约50% 。下面的程序接收一个输入文件并将之写入一个只有一项的压缩的 Zip 文件: import java.io.*;import java.util.zip.*; public class compress public static void doit(String filein, String fileout) FileInputStream fis = null; FileOutputStream fos = null; try fis = new FileInputStream

24、(filein); fos = new FileOutputStream(fileout); ZipOutputStream zos = new ZipOutputStream(fos); ZipEntry ze = new ZipEntry(filein); zos.putNextEntry(ze); final int BUFSIZ = 4096; byte inbuf = new byteBUFSIZ; int n; while (n = fis.read(inbuf) != -1) zos.write(inbuf, 0, n); fis.close(); fis = null; zos