NIO笔记-缓存器细节

XiongNeng 收录于 Java

2015-06-20 2026-05-24 约 1800 字预计阅读 4 分钟

Buffer由数据和可以高效访问以及操纵这些数据的四个索引组成，这四个索引是：mark、position、limit、capacity。下表是用于设置和复位索引以及查询它们的方法：

方法	说明
capacity()	返回缓存区容量
clear()	清空缓存区，position=0，limit=capacity，此方法可覆写缓存区
flip()	limit=position，position=0，用于准备从缓存区读取已经写入的数据
limit()	返回limit的值
limit(int lim)	设置limit的值
mark()	将mark设置为position
position()	返回position的值
position(int pos)	设置position的值
remaining()	返回(limit - position)
hasRemaining()	若有介于position和limit之间的元素，返回true
reset()	将position设置为mark
rewind()	将position设置为0，也就是缓存区的开始位置

在缓存区中插入和提取数据的方法会更新这些索引，用于反映所发生的变化。

下面的示例用到一个很简单的算法 - 交换相邻字符，以对CharBuffer中的字符进行编码和译码

 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
public class UsingBuffers {
	private static void symmetricScramble(CharBuffer buffer) {
		while (buffer.hasRemaining()) {
			buffer.mark();
			char c1 = buffer.get();
			char c2 = buffer.get();
			buffer.reset();
			buffer.put(c2).put(c1);
		}
	}

	public static void main(String[] args) {
		char[] data = "UsingBuffers".toCharArray();
		ByteBuffer bb = ByteBuffer.allocate(data.length * 2);
		CharBuffer cb = bb.asCharBuffer();
		cb.put(data);
		print(cb.rewind());
		symmetricScramble(cb);
		print(cb.rewind());
		symmetricScramble(cb);
		print(cb.rewind());
	}
} /*
  * Output: UsingBuffers sUniBgfuefsr UsingBuffers
  */// :~

尽管可以通过对某个char数组调用wrap方法直接产生一个CharBuffer，但是在本例中取而代之的是分配一个底层的ByteBuffer，产生的CharBuffer只是ByteBuffer上的一个视图而已。这里强调的是，我们总是以操纵ByteBuffer为目标，因为只有它才可以和通道进行交互。

刚开始的时候，position指向缓存区第一个元素，capacity和limit指向最后一个元素。

调用get方法和put方法的时候，position指针向前移动1个单位，具体移动几个字节byte，要看数据占用位数大小。有个重载的get和put方法，带索引参数，不过，这些方法不改变position指针。

mark()方法会在当前位置打个标记，为了以后reset的时候position可以返回这个remark处。

可以直接用带参的put方法去设置相应位置的值，也可以先reset到remark处后，put值。

while循环最后，position指向缓存区的末尾了。如果要打印缓存区，只能打印出position和limit之间的字符，也就是啥都没了。因此这时候要显示缓存区的内容，必须使用rewind() 把position设置到缓存区开始位置，这时候mark值变得不明确了。

内存映射文件 - 创建和修改大文件

先看一个瞬间创建一个128M的大文件的例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
public class LargeMappedFiles {
  static int length = 0x8FFFFFF; // 128 MB
  public static void main(String[] args) throws Exception {
    MappedByteBuffer out =
      new RandomAccessFile("test.dat", "rw").getChannel()
      .map(FileChannel.MapMode.READ_WRITE, 0, length);
    for(int i = 0; i < length; i++)
      out.put((byte)'x');
    print("Finished writing");
    for(int i = length/2; i < length/2 + 6; i++)
      printnb((char)out.get(i));
  }
} ///:~

为了既能读又能写，我们先由RandomAccessFile开始，获得该文件上的通道，然后调用map() 产生MappedByteBuffer，这是一种特殊类型的直接缓存器。我们必须指定映射文件的初始位置和映射区域的长度，这意味着我们可以映射某个大文件的较小的部分。

用这种方式，很大的文件可达2GB也可以很容易的修改。

相比较旧的IO流而言，映射文件访问方式可以大大的提高性能。映射写必须要用RandomAccessFile。

文件加锁

Java的文件加锁直接映射到了本地操作系统的加锁工具上，因此文件锁对于其他操作系统进程是可见的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
public class FileLocking {
  public static void main(String[] args) throws Exception {
    FileOutputStream fos= new FileOutputStream("file.txt");
    FileLock fl = fos.getChannel().tryLock();
    if(fl != null) {
      System.out.println("Locked File");
      TimeUnit.MILLISECONDS.sleep(100);
      fl.release();
      System.out.println("Released Lock");
    }
    fos.close();
  }
} /* Output:
Locked File
Released Lock
*///:~

对映射文件的部分加锁

文件映射通常应用于极大文件，我们可能需要对这种巨大文件进行部分加锁，其他进程可以修改文件中未被加锁的部分。例如数据库文件就是这样。

 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
public class LockingMappedFiles {
  static final int LENGTH = 0x8FFFFFF; // 128 MB
  static FileChannel fc;
  public static void main(String[] args) throws Exception {
    fc =
      new RandomAccessFile("test.dat", "rw").getChannel();
    MappedByteBuffer out =
      fc.map(FileChannel.MapMode.READ_WRITE, 0, LENGTH);
    for(int i = 0; i < LENGTH; i++)
      out.put((byte)'x');
    new LockAndModify(out, 0, 0 + LENGTH/3);
    new LockAndModify(out, LENGTH/2, LENGTH/2 + LENGTH/4);
  }
  private static class LockAndModify extends Thread {
    private ByteBuffer buff;
    private int start, end;
    LockAndModify(ByteBuffer mbb, int start, int end) {
      this.start = start;
      this.end = end;
      mbb.limit(end);
      mbb.position(start);
      buff = mbb.slice();
      start();
    }
    public void run() {
      try {
        // Exclusive lock with no overlap:
        FileLock fl = fc.lock(start, end, false);
        System.out.println("Locked: "+ start +" to "+ end);
        // Perform modification:
        while(buff.position() < buff.limit() - 1)
          buff.put((byte)(buff.get() + 1));
        fl.release();
        System.out.println("Released: "+start+" to "+ end);
      } catch(IOException e) {
        throw new RuntimeException(e);
      }
    }
  }
}