RandomAccessFile类优化

最新推荐文章于 2023-04-23 21:34:04 发布
最新推荐文章于 2023-04-23 21:34:04 发布
阅读量2.4k 收藏 2
点赞数
分类专栏： 他山之石 文章标签： byte buffer 优化 磁盘 jdk class
 

通过扩展RandomAccessFile类使之具备Buffer改善I/O性能

JAVA的文件随机存取类（RandomAccessFile）的I/O效率较低。通过分析其中原因，提出解决方案。逐步展示如何创建具备缓存读写能力的文件随机存取类，并进行了优化。通过与其它文件访问类的性能对比，证明了其实用价值。

主体：

目前最流行的J2SDK版本是1.3系列。使用该版本的开发人员需文件随机存取，就得使用RandomAccessFile类。其I/O性能较之其它常用开发语言的同类性能差距甚远，严重影响程序的运行效率。

开发人员迫切需要提高效率，下面分析RandomAccessFile等文件类的源代码，找出其中的症结所在，并加以改进优化，创建一个"性/价比"俱佳的随机文件访问类BufferedRandomAccessFile。

1．在改进之前先做一个基本测试：逐字节COPY一个12兆的文件（这里牵涉到读和写）。

读写耗用时间（秒）
RandomAccessFileRandomAccessFile95.848
BufferedInputStream + DataInputStreamBufferedOutputStream + DataOutputStream2.935

我们可以看到两者差距约32倍，RandomAccessFile也太慢了。先看看两者关键部分的源代码，对比分析，找出原因。

1．1．[RandomAccessFile]


public class RandomAccessFile implements DataOutput, DataInput {
 public final byte readByte() throws IOException {
  int ch = this.read();
  if (ch < 0)
   throw new EOFException();
  return (byte)(ch);
 }

 public native int read() throws IOException; 

 public final void writeByte(int v) throws IOException {
  write(v);
 } 

 public native void write(int b) throws IOException; 
}

可见，RandomAccessFile每读/写一个字节就需对磁盘进行一次I/O操作。

1．2．[BufferedInputStream]


public class BufferedInputStream extends FilterInputStream {
 private static int defaultBufferSize = 2048; 
 protected byte buf[]; // 建立读缓存区
 public BufferedInputStream(InputStream in, int size) {
  super(in);         
  if (size <= 0) {
   throw new IllegalArgumentException("Buffer size <= 0");
  }
  buf = new byte[size];
 }
 public synchronized int read() throws IOException {
  ensureOpen();
  if (pos >= count) {
   fill();
   if (pos >= count)
    return -1;
  }
  return buf[pos++] & 0xff; // 直接从BUF[]中读取
 } 
 private void fill() throws IOException {
 if (markpos < 0)
      pos = 0;  /* no mark: throw away the buffer */
 else if (pos >= buf.length) /* no room left in buffer */
      if (markpos > 0) { /* can throw away early part of the buffer */
  int sz = pos - markpos;
  System.arraycopy(buf, markpos, buf, 0, sz);
  pos = sz;
  markpos = 0;
      } else if (buf.length >= marklimit) {
  markpos = -1; /* buffer got too big, invalidate mark */
  pos = 0; /* drop buffer contents */
      } else {  /* grow buffer */
  int nsz = pos * 2;
  if (nsz > marklimit)
       nsz = marklimit;
  byte nbuf[] = new byte[nsz];
  System.arraycopy(buf, 0, nbuf, 0, pos);
  buf = nbuf;
      }
 count = pos;
 int n = in.read(buf, pos, buf.length - pos);
 if (n > 0)
      count = n + pos;
 }
}

1．3．[BufferedOutputStream]


public class BufferedOutputStream extends FilterOutputStream {
    protected byte buf[]; // 建立写缓存区
    public BufferedOutputStream(OutputStream out, int size) {
  super(out);
  if (size <= 0) {
   throw new IllegalArgumentException("Buffer size <= 0");
  }
  buf = new byte[size];
     } 
public synchronized void write(int b) throws IOException {
  if (count >= buf.length) {
       flushBuffer();
  }
  buf[count++] = (byte)b; // 直接从BUF[]中读取
    }

    private void flushBuffer() throws IOException {
  if (count > 0) {
   out.write(buf, 0, count);
   count = 0;
  }
    }
}

可见，Buffered I/O putStream每读/写一个字节，若要操作的数据在BUF中，就直接对内存的buf[]进行读/写操作；否则从磁盘相应位置填充buf[]，再直接对内存的buf[]进行读/写操作，绝大部分的读/写操作是对内存buf[]的操作。

1．3．小结

内存存取时间单位是纳秒级（10E-9），磁盘存取时间单位是毫秒级（10E-3），同样操作一次的开销，内存比磁盘快了百万倍。理论上可以预见，即使对内存操作上万次，花费的时间也远少对于磁盘一次I/O的开销。显然后者是通过增加位于内存的BUF存取，减少磁盘I/O的开销，提高存取效率的，当然这样也增加了BUF控制部分的开销。从实际应用来看，存取效率提高了32倍。

2．根据1.3得出的结论，现试着对RandomAccessFile类也加上缓冲读写机制。

随机访问类与顺序类不同，前者是通过实现DataInput/DataOutput接口创建的，而后者是扩展FilterInputStream/FilterOutputStream创建的，不能直接照搬。

2．1．开辟缓冲区BUF[默认：1024字节]，用作读/写的共用缓冲区。

2．2．先实现读缓冲。

读缓冲逻辑的基本原理：

A 欲读文件POS位置的一个字节。

B 查BUF中是否存在？若有，直接从BUF中读取，并返回该字符BYTE。

C 若没有，则BUF重新定位到该POS所在的位置并把该位置附近的BUFSIZE的字节的文件内容填充BUFFER，返回B。

以下给出关键部分代码及其说明：


public class BufferedRandomAccessFile extends RandomAccessFile {
//   byte read(long pos)：读取当前文件POS位置所在的字节
//   bufstartpos、bufendpos代表BUF映射在当前文件的首/尾偏移地址。
//   curpos指当前类文件指针的偏移地址。
     public byte read(long pos) throws IOException {
         if (pos < this.bufstartpos || pos > this.bufendpos ) {
             this.flushbuf();
             this.seek(pos);

             if ((pos < this.bufstartpos) || (pos > this.bufendpos)) 
                 throw new IOException();
         }
         this.curpos = pos;
         return this.buf[(int)(pos - this.bufstartpos)];
     }

// void flushbuf()：bufdirty为真，把buf[]中尚未写入磁盘的数据，写入磁盘。

     private void flushbuf() throws IOException {
         if (this.bufdirty == true) {
             if (super.getFilePointer() != this.bufstartpos) {
                 super.seek(this.bufstartpos);
             }
             super.write(this.buf, 0, this.bufusedsize);
             this.bufdirty = false;
         }
     }

// void seek(long pos)：移动文件指针到pos位置，并把buf[]映射填充至POS
所在的文件块。
     public void seek(long pos) throws IOException {
         if ((pos < this.bufstartpos) || (pos > this.bufendpos)) { // seek pos not in buf
             this.flushbuf();
             if ((pos >= 0) && (pos <= this.fileendpos) && (this.fileendpos != 0)) 
{    // seek pos in file (file length > 0)
                 this.bufstartpos =   pos * bufbitlen / bufbitlen;
                 this.bufusedsize = this.fillbuf();

             } else if (((pos == 0) && (this.fileendpos == 0)) 
|| (pos == this.fileendpos + 1)) 
{    // seek pos is append pos
                 this.bufstartpos = pos;
                 this.bufusedsize = 0;
             }
             this.bufendpos = this.bufstartpos + this.bufsize - 1;
         }
         this.curpos = pos;
     }
// int fillbuf()：根据bufstartpos，填充buf[]。
     private int fillbuf() throws IOException {
         super.seek(this.bufstartpos);
         this.bufdirty = false;
         return super.read(this.buf);
     }
}

至此缓冲读基本实现，逐字节COPY一个12兆的文件（这里牵涉到读和写，用BufferedRandomAccessFile试一下读的速度）：

读写耗用时间（秒）
RandomAccessFileRandomAccessFile95.848
BufferedRandomAccessFileBufferedOutputStream + DataOutputStream2.813
BufferedInputStream + DataInputStreamBufferedOutputStream + DataOutputStream2.935

可见速度显著提高，与BufferedInputStream+DataInputStream不相上下。

2．3．实现写缓冲。

写缓冲逻辑的基本原理：

A欲写文件POS位置的一个字节。

B 查BUF中是否有该映射？若有，直接向BUF中写入，并返回true。

C若没有，则BUF重新定位到该POS所在的位置，并把该位置附近的 BUFSIZE字节的文件内容填充BUFFER，返回B。

下面给出关键部分代码及其说明：


// boolean write(byte bw, long pos)：向当前文件POS位置写入字节BW。
// 根据POS的不同及BUF的位置：存在修改、追加、BUF中、BUF外等情
况。在逻辑判断时，把最可能出现的情况，最先判断，这样可提高速度。
// fileendpos：指示当前文件的尾偏移地址，主要考虑到追加因素
     public boolean write(byte bw, long pos) throws IOException {
         if ((pos >= this.bufstartpos) && (pos <= this.bufendpos)) { 
// write pos in buf
             this.buf[(int)(pos - this.bufstartpos)] = bw;
             this.bufdirty = true;

             if (pos == this.fileendpos + 1) { // write pos is append pos
                 this.fileendpos++;
                 this.bufusedsize++;
             }
         } else { // write pos not in buf
             this.seek(pos);
             if ((pos >= 0) && (pos <= this.fileendpos) && (this.fileendpos != 0)) 
{ // write pos is modify file
                 this.buf[(int)(pos - this.bufstartpos)] = bw;
             } else if (((pos == 0) && (this.fileendpos == 0)) 
|| (pos == this.fileendpos + 1)) { // write pos is append pos
                 this.buf[0] = bw;
                 this.fileendpos++;
                 this.bufusedsize = 1;
             } else {
                 throw new IndexOutOfBoundsException();
             }
             this.bufdirty = true;
         }
         this.curpos = pos;
         return true;
     }

至此缓冲写基本实现，逐字节COPY一个12兆的文件，（这里牵涉到读和写，结合缓冲读，用BufferedRandomAccessFile试一下读/写的速度）：

读写耗用时间（秒）
RandomAccessFileRandomAccessFile95.848
BufferedInputStream + DataInputStreamBufferedOutputStream + DataOutputStream2.935
BufferedRandomAccessFileBufferedOutputStream + DataOutputStream2.813
BufferedRandomAccessFileBufferedRandomAccessFile2.453

可见综合读/写速度已超越BufferedInput/OutputStream+DataInput/OutputStream。

3．优化BufferedRandomAccessFile。

优化原则：

  • 调用频繁的语句最需要优化，且优化的效果最明显。
  • 多重嵌套逻辑判断时，最可能出现的判断，应放在最外层。
  • 减少不必要的NEW。

这里举一典型的例子：


    public void seek(long pos) throws IOException {
  ...
this.bufstartpos =   pos * bufbitlen / bufbitlen; 
// bufbitlen指buf[]的位长，例：若bufsize=1024，则bufbitlen=10。
...
}

seek函数使用在各函数中，调用非常频繁，上面加重的这行语句根据pos和bufsize确定buf[]对应当前文件的映射位置，用"*"、"/"确定，显然不是一个好方法。

优化一：this.bufstartpos = (pos << bufbitlen) >> bufbitlen;

优化二：this.bufstartpos = pos & bufmask; // this.bufmask = ~((long)this.bufsize - 1);

两者效率都比原来好，但后者显然更好，因为前者需要两次移位运算、后者只需一次逻辑与运算（bufmask可以预先得出）。

至此优化基本实现，逐字节COPY一个12兆的文件，（这里牵涉到读和写，结合缓冲读，用优化后BufferedRandomAccessFile试一下读/写的速度）：

读写耗用时间（秒）
RandomAccessFileRandomAccessFile95.848
BufferedInputStream + DataInputStream BufferedOutputStream + DataOutputStream2.935
BufferedRandomAccessFileBufferedOutputStream + DataOutputStream2.813
BufferedRandomAccessFileBufferedRandomAccessFile2.453
BufferedRandomAccessFile优BufferedRandomAccessFile优2.197

可见优化尽管不明显，还是比未优化前快了一些，也许这种效果在老式机上会更明显。

以上比较的是顺序存取，即使是随机存取，在绝大多数情况下也不止一个BYTE，所以缓冲机制依然有效。而一般的顺序存取类要实现随机存取就不怎么容易了。

4．需要完善的地方

提供文件追加功能：


     public boolean append(byte bw) throws IOException {
         return this.write(bw, this.fileendpos + 1);
     }

提供文件当前位置修改功能：


     public boolean write(byte bw) throws IOException {
         return this.write(bw, this.curpos);
     }

返回文件长度（由于BUF读写的原因，与原来的RandomAccessFile类有所不同）：


     public long length() throws IOException {
         return this.max(this.fileendpos + 1, this.initfilelen);
     }

返回文件当前指针（由于是通过BUF读写的原因，与原来的RandomAccessFile类有所不同）：


     public long getFilePointer() throws IOException {
         return this.curpos;
     }

提供对当前位置的多个字节的缓冲写功能：


     public void write(byte b[], int off, int len) throws IOException {
         long writeendpos = this.curpos + len - 1;
         if (writeendpos <= this.bufendpos) { // b[] in cur buf
System.arraycopy(b, off, this.buf, (int)(this.curpos - this.bufstartpos), 
len);
             this.bufdirty = true;
             this.bufusedsize = (int)(writeendpos - this.bufstartpos + 1);
         } else { // b[] not in cur buf
             super.seek(this.curpos);
             super.write(b, off, len);
         }
         if (writeendpos > this.fileendpos)
             this.fileendpos = writeendpos;

         this.seek(writeendpos+1);
}

     public void write(byte b[]) throws IOException {
         this.write(b, 0, b.length);
     }

提供对当前位置的多个字节的缓冲读功能：


public int read(byte b[], int off, int len) throws IOException {
long readendpos = this.curpos + len - 1;
    if (readendpos <= this.bufendpos && readendpos <= this.fileendpos ) { 
// read in buf
       System.arraycopy(this.buf, (int)(this.curpos - this.bufstartpos), 
b, off, len);
    } else { // read b[] size > buf[]
      if (readendpos > this.fileendpos) { // read b[] part in file
         len = (int)(this.length() - this.curpos + 1);
        }
        super.seek(this.curpos);
        len = super.read(b, off, len);
        readendpos = this.curpos + len - 1;
    }
        this.seek(readendpos + 1);
        return len;
}

    public int read(byte b[]) throws IOException {
         return this.read(b, 0, b.length);
    }

public void setLength(long newLength) throws IOException {
         if (newLength > 0) {
             this.fileendpos = newLength - 1;
         } else {
             this.fileendpos = 0;
         }
         super.setLength(newLength);
}
     
public void close() throws IOException {
         this.flushbuf();
         super.close();
     }

至此完善工作基本完成，试一下新增的多字节读/写功能，通过同时读/写1024个字节，来COPY一个12兆的文件，（这里牵涉到读和写，用完善后BufferedRandomAccessFile试一下读/写的速度）：

读写耗用时间（秒）
RandomAccessFileRandomAccessFile95.848
BufferedInputStream + DataInputStreamBufferedOutputStream + DataOutputStream2.935
BufferedRandomAccessFileBufferedOutputStream + DataOutputStream2.813
BufferedRandomAccessFileBufferedRandomAccessFile2.453
BufferedRandomAccessFile优BufferedRandomAccessFile优2.197
BufferedRandomAccessFile完BufferedRandomAccessFile完0.401

5．与JDK1.4新类MappedByteBuffer+RandomAccessFile的对比？

JDK1.4提供了NIO类 ，其中MappedByteBuffer类用于映射缓冲，也可以映射随机文件访问，可见JAVA设计者也看到了RandomAccessFile的问题，并加以改进。怎么通过MappedByteBuffer+RandomAccessFile拷贝文件呢？下面就是测试程序的主要部分：


RandomAccessFile rafi = new RandomAccessFile(SrcFile, "r");
    RandomAccessFile rafo = new RandomAccessFile(DesFile, "rw");
 FileChannel fci = rafi.getChannel();
FileChannel fco = rafo.getChannel();
 long size = fci.size();
 MappedByteBuffer mbbi = fci.map(FileChannel.MapMode.READ_ONLY, 0, size);
MappedByteBuffer mbbo = fco.map(FileChannel.MapMode.READ_WRITE, 0, size);
long start = System.currentTimeMillis();
for (int i = 0; i < size; i++) {
             byte b = mbbi.get(i);
             mbbo.put(i, b);
}
fcin.close();
fcout.close();
rafi.close();
rafo.close();
System.out.println("Spend: "+(double)(System.currentTimeMillis()-start) / 1000 + "s");

试一下JDK1.4的映射缓冲读/写功能，逐字节COPY一个12兆的文件，（这里牵涉到读和写）：

读写耗用时间（秒）
RandomAccessFileRandomAccessFile95.848
BufferedInputStream + DataInputStreamBufferedOutputStream + DataOutputStream2.935
BufferedRandomAccessFileBufferedOutputStream + DataOutputStream2.813
BufferedRandomAccessFileBufferedRandomAccessFile2.453
BufferedRandomAccessFile优BufferedRandomAccessFile优2.197
BufferedRandomAccessFile完BufferedRandomAccessFile完0.401
MappedByteBuffer+ RandomAccessFileMappedByteBuffer+ RandomAccessFile1.209

确实不错，看来JDK1.4比1.3有了极大的进步。如果以后采用1.4版本开发软件时，需要对文件进行随机访问，建议采用MappedByteBuffer+RandomAccessFile的方式。但鉴于目前采用JDK1.3及以前的版本开发的程序占绝大多数的实际情况，如果您开发的JAVA程序使用了RandomAccessFile类来随机访问文件，并因其性能不佳，而担心遭用户诟病，请试用本文所提供的BufferedRandomAccessFile类，不必推翻重写，只需IMPORT 本类，把所有的RandomAccessFile改为BufferedRandomAccessFile，您的程序的性能将得到极大的提升，您所要做的就这么简单。

6．未来的考虑

读者可在此基础上建立多页缓存及缓存淘汰机制，以应付对随机访问强度大的应用。
秘恋气质美女
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
花1K内存实现高效I-O的RandomAccessFile类
08-28
花1K内存实现高效I-O的RandomAccessFile类 自己搜搜这个关键字. 我主要是用来优化Android上多线程断点下载的写文件效率 RandomAccessFile是操作硬盘的,比操作内存的数据慢了几百万倍, 所有有人做出优化,我特上传代码
花1K内存实现高效I/O的RandomAccessFile类
鲤鱼商城
11-28 3031
花1K内存实现高效I/O的RandomAccessFile类英文原文内容：在改进之前先做一个基本测试：逐字节COPY一个12兆的文件根据1.3得出的结论，现试着对RandomAccessFile类也加上缓冲读写机制优化BufferedRandomA
RandomAccessFile读性能优化
qq_35939417的博客
10-19 1753
公司的日志采集器是我自己开发的，没用开源产品。日志采集虽然是个小功能，但是要想写好也没那么容易。对于一个日志采集器来说，它应该稳定、可控、占用尽量少的资源。因为日志采集器是和核心业务服务部署在同一台服务器上，如果它工作时CPU和内存占用率飙升、重度磁盘I/O，显然是不合适的，毕竟只是一个辅助功能，不能因小失大。在生产环境运行时发现部分服务日志过多，日志采集器的采集速度跟不上，日志上报有较大延迟。在对我自己编写的代码进行优化后，我想看看jdk的代码有没有优化的空间。
JavaIO流RandomAccessFile详细用法
LorraineWen的博客
04-23 461
上次介绍了非流式部分的File类，这次来介绍RandomAccessFile类，这个类对文件操作的功能十分强大，相比于其他只能读或者只能写的文件类，这个类既能对文件进行读也能对文件进行写，RandomAccessFile把随机访问的文件对象看作存储在文件系统中的一个大型 byte 数组，然后通过指向该 byte 数组的索引或者文件指针在该数组任意位置读取或写入任意数据。（如果这个文件不存在，则会自动创建一个同名文件）。4.rwd:将文件的内容同步更新到磁盘，但不修改文件的数据。
RandomAccessFile和对象序列化
weixin_44250329的博客
08-19 227
RandomAccessFile RandomAccessFile类是java.io包中一个特别的类，简称随机访问文件流，这里的“随机”不是随机读取或者写入的意思，而是说可以使用该类实现在文件的任意位置进行读写操作；因此，该类既可以实现输入流(InputStream)相关功能，也能实现输出流(OutputStream)相关功能，另外RandomAccessFile类从DataInput和Data...
深入分析:用1K内存实现高效I/O的RandomAccessFile类的详解
09-05
本文主要探讨如何通过优化RandomAccessFile类来提高Java中的I/O性能，特别是针对大文件的处理。在Java 1.3版本中，RandomAccessFile类的I/O效率相对较低，这在处理大量数据时会显著影响程序性能。为了解决这个问题，...
java海量数据读写优化方案
09-06
对大数据文本文件读取（按行读取）的优化，目前常规的方案有三种，第一种LineNumberReader，第二种RandomAccessFile，第三种是内存映射文件在RandomAccessFile基础上调用getChannel().map(...)；代码提供在...
RandomAccessFile的用法
01-08
Java的`RandomAccessFile`类是Java I/O流体系中的一种特殊类型，它允许程序员以随机访问模式读取和写入文件。与传统的输入/输出流不同，`...在实际项目中，可以根据需求结合其他I/O类和并发机制，优化文件操作性能。
轻松实现超大文件分片上传.zip
10-20
4. **RandomAccessFile**：在Java中，使用RandomAccessFile类可以高效地对文件进行随机读写，这对于文件分片上传非常有用。它允许我们精确地定位到文件的任意位置进行读写操作，尤其在需要修改已上传分片或重新上传...
Java RandomAccessFile类（随机读取）
qq_57389269的博客
07-18 207
可利用RandomAccessFile实现对文件指定部分的操作。 import java.io.*; /* 利用RandomAccessFile实现对文件指定部分的操作。 */ public class RandomAccessFile类 { public static void main(String[] args) throws IOException { RandomAccessFile raf = new RandomAccessFile(new File(...
RandomAccessFile随机访问文件，可读可写
xiyangyang8110的博客
01-24 359
//字符流 高级流有缓存 flush() 流用完之后要关闭 close(); public static void main(String[] args) throws IOException { // TODO Auto-generated method stub RandomAccessFile raf = new RandomAccessFil
java学习日记day27
azure10492的博客
08-09 270
复习: 1.字节流(缓冲) 父类: InputStream/OutputStream FileInputStream("相对路径") - 输入流 read() - 读单个字节 read(byte[]) - 字节数组 FileOutputStream("相对路径",true) - 输出流 write(int) write(byte[]) write...
randomaccessfile在移动设备多线程多服务器下载时写入慢的问题
weixin_34244102的博客
01-27 302
在移动设备中使用randomaccessfile类多线程多服务器下载时要注意一次性写入尽可能写入多的数据。写入次数尽可能的减少。 如果每次写入1k数据。你的下载速度撑死200kb/s。如果你的设备闪存为ufs可能会更快。 事实证明pc存储速度远高于移动设备。安卓模拟器模拟的app不算数。要在移动设备真机运行。 如果每次写入1m数据。那么你的下载速度可以达到你的带宽上限。 那么如何尽可能写入...
具有buffer功能的RandomAccessFile
hpb21的专栏
04-28 3525
在进行多线程下载过程中，采用RandomAccessFile对文件进行写操作，线程对磁盘的读写非常频繁，导致出现机器顿卡，或一些其他问题。采用具有缓冲的RandomAccessFile后，能快速降低磁盘IO。    开发人员迫切需要提高效率，下面分析RandomAccessFile等文件类的源代码，找出其中的症结所在，并加以改进优化，创建一个"性/价比"俱佳的随机文件访问类Buf
java bufferedrandomaccessfile_java 读写操作大文件 BufferedReader和RandomAccessFile
weixin_33501343的博客
02-26 294
一老问这问题，两个都答出来算加分项？二具体代码如下，没什么好说的直接说对比。BufferedReader和RandomAccessFile的区别RandomAccessFile 在数据越大，性能越差。因为他是数据文件的一个channel，支持读改原数据文件。BufferedReader是读改数据文件的一个在内存的副本。那RandomAccessFile的优点？1.RandomAccessFile忽...
[IO流]RandomAccessFile实现数据的读写及插入操作
self
05-08 981
/* RandomAccessFile的使用 1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口 2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流 mode参数： r:以只读方式打开 rw:打开以便读取和写入 rwd:打开以便读取和写入;同步文件内容的更新 rws:打开以便读取和写入;同步文件内容和元数据的更新 3.如果RandomAccessFile作为.
java io buffer状态_RandomAccessFile用法 MappedByteBuffer详解 共享内存
weixin_39830020的博客
03-04 365
一、RandomAccessFile用法1、用于随机读和随机写2、提供多种数据类型的读和写特殊说明：bytes = new byte[8];output.write(bytes, 0, 0); //可以写0字节byte[] bytes = null;output.write(bytes, 0, 0); //会触发抛异常二、MappedByteBuffer详解FileInputStream.read...
Java基础：异常与错误（Exception&Error）
天然玩家的博客
02-15 1088
Java的Error和Exception是不同的，可以通过源码注释了解一二。 而Exception可以分成三类：IOException、RuntimeException和ReflectiveOperationException，详见文章。
java RandomAccessFile性能优化
最新发布
07-08
对于Java中的RandomAccessFile，可以考虑以下几个方面来优化性能： 1. 缓冲区：使用缓冲区可以减少磁盘I/O次数，提高读写性能。可以通过使用BufferedInputStream和BufferedOutputStream来包装RandomAccessFile，实现缓冲读写。 2. 批量读写：尽量减少读写操作的次数，可以采用批量读写的方式，即一次性读取或写入多个字节或字符。 3. 内存映射文件：Java提供了内存映射文件（MappedByteBuffer）的机制，可以将文件直接映射到内存中，从而减少了磁盘I/O的次数，提高了读写性能。 4. 随机访问：RandomAccessFile支持随机访问文件的任意位置，但频繁的随机访问可能会导致性能下降。可以考虑按块顺序读取或写入数据，尽量减少随机访问的次数。 5. 合理关闭资源：在使用完RandomAccessFile后，应该及时关闭资源，释放系统资源。 6. 并发处理：如果需要并发读写文件，可以考虑使用多线程或者异步IO来提高性能。 这些是优化RandomAccessFile性能的一些常见方法，具体的优化策略需要根据具体的场景和需求进行选择和调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值