0
点赞
收藏
分享

微信扫一扫

Java NIO——MappedByteBuffer

時小白 2022-10-17 阅读 107
物理内存虚拟内存页帧MappedByteBuffernioJava编程语言

前言

java io操作中通常采用BufferedReader，BufferedInputStream等带缓冲的IO类处理大文件，不过java nio中引入了一种基于MappedByteBuffer操作大文件的方式，其读写性能极高。

内存管理

在深入MappedByteBuffer之前，先看看计算机内存管理的几个术语：

  • MMU：CPU的内存管理单元。

  • 物理内存：即内存条的内存空间。

  • 虚拟内存：计算机系统内存管理的一种技术。它使得应用程序认为它拥有连续的可用的内存（一个连续完整的地址空间），而实际上，它通常是被分隔成多个物理内存碎片，还有部分暂时存储在外部磁盘存储器上，在需要时进行数据交换。

  • 页面文件：操作系统反映构建并使用虚拟内存的硬盘空间大小而创建的文件，在windows下，即pagefile.sys文件，其存在意味着物理内存被占满后，将暂时不用的数据移动到硬盘上。

  • 缺页中断：当程序试图访问已映射在虚拟地址空间中但未被加载至物理内存的一个分页时，由MMC发出的中断。如果操作系统判断此次访问是有效的，则尝试将相关的页从虚拟内存文件中载入物理内存。

为什么会有虚拟内存和物理内存的区别？

如果正在运行的一个进程，它所需的内存是有可能大于内存条容量之和的，如内存条是256M，程序却要创建一个2G的数据区，那么所有数据不可能都加载到内存（物理内存），必然有数据要放到其他介质中（比如硬盘），待进程需要访问那部分数据时，再调度进入物理内存。

什么是虚拟内存地址和物理内存地址？

假设你的计算机是32位，那么它的地址总线是32位的，也就是它可以寻址00xFFFFFFFF（4G）的地址空间，但如果你的计算机只有256M的物理内存0x0x0FFFFFFF（256M），同时你的进程产生了一个不在这256M地址空间中的地址，那么计算机该如何处理呢？回答这个问题前，先说明计算机的内存分页机制。

 

计算机会对虚拟内存地址空间（32位为4G）进行分页产生页（page），对物理内存地址空间（假设256M）进行分页产生页帧（page frame），页和页帧的大小一样，所以虚拟内存页的个数势必要大于物理内存页帧的个数。在计算机上有一个页表（page table），就是映射虚拟内存页到物理内存页的，更确切的说是页号到页帧号的映射，而且是一对一的映射。

 

问题来了，虚拟内存页的个数 > 物理内存页帧的个数，岂不是有些虚拟内存页的地址永远没有对应的物理内存地址空间？不是的，操作系统是这样处理的。操作系统有个页面失效（page fault）功能。操作系统找到一个最少使用的页帧，使之失效，并把它写入磁盘，随后把需要访问的页放到页帧中，并修改页表中的映射，保证了所有的页都会被调度。

现在来看看什么是虚拟内存地址和物理内存地址：

  • 虚拟内存地址：由页号（与页表中的页号关联）和偏移量（页的小大，即这个页能存多少数据）组成。

举个例子，有一个虚拟地址它的页号是4，偏移量是20，那么他的寻址过程是这样的：首先到页表中找到页号4对应的页帧号（比如为8），如果页不在内存中，则用失效机制调入页，接着把页帧号和偏移量传给MMC组成一个物理上真正存在的地址，最后就是访问物理内存的数据了。

案例：

MappedByteBuffer修改文件

/**
 * MappedByteBuffer 可让文件直接在内存(堆外内存)修改,
 * 操作系统不需要在内核空间和用户空间来回的拷贝
 */
public class MappedByteBufferTest {

    public static void main(String[] args) throws Exception {
        RandomAccessFile randomAccessFile = new RandomAccessFile("input.txt", "rw");
        //获取对应的通道
        FileChannel channel = randomAccessFile.getChannel();

        /**
         * 参数1：FileChannel.MapMode.READ_WRITE 使用的读写模式
         * 参数2：0 可以直接修改的起始位置
         * 参数3: 5 是映射到内存的大小(不是索引位置) ,即将 input.txt 的多少个字节映射到内存
         * 可以直接修改的范围就是 0-5
         * 实际类型 DirectByteBuffer
         */
        MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);
        mappedByteBuffer.put(0,(byte) 'H');
        mappedByteBuffer.put(3,(byte) '9');
        //mappedByteBuffer.put(5,(byte) 'Y');//IndexOutOfBoundsException

        randomAccessFile.close();
        System.out.println("修改成功");
    }
}

从继承结构上看，MappedByteBuffer继承自ByteBuffer，ByteBuffer继承自Buffer，Buffer内部维护了一个逻辑地址address(long address)。

map过程

FileChannel提供了map方法把文件映射到虚拟内存，通常情况可以映射整个文件，如果文件比较大，可以进行分段映射。

FileChannel中的几个变量：

  • MapMode mode：内存映像文件访问的方式，共三种：

    • MapMode.READ_ONLY：只读，试图修改得到的缓冲区将导致抛出异常。
    • MapMode.READ_WRITE：读/写，对得到的缓冲区的更改最终将写入文件；但该更改对映射到同一文件的其他程序不一定是可见的。

  • MapMode.PRIVATE：私用，可读可写，但是修改的内容不会写入文件，只是buffer自身的改变，这种能力称之为”copy on write”。

  • position：文件映射时的起始位置。

  • allocationGranularity：Memory allocation size for mapping buffers，通过native函数initIDs初始化。

接下去通过分析源码，了解一下map过程的内部实现。

  • 通过RandomAccessFile获取FileChannel。
public final FileChannel getChannel() {
	synchronized (this) {
		if (channel == null) {
			channel = FileChannelImpl.open(fd, path, true, rw, this);
		}
		return channel;
	}
}

上述实现可以看出，由于synchronized同步代码块 ，不会有线程安全问题。

通过FileChannel.map方法，把文件映射到虚拟内存，并返回逻辑地址address，实现如下：

public MappedByteBuffer map(MapMode var1, long var2, long var4) throws IOException {
	this.ensureOpen();
	if (var1 == null) {
		throw new NullPointerException("Mode is null");
	} else if (var2 < 0L) {
		throw new IllegalArgumentException("Negative position");
	} else if (var4 < 0L) {
		throw new IllegalArgumentException("Negative size");
	} else if (var2 + var4 < 0L) {
		throw new IllegalArgumentException("Position + size overflow");
	} else if (var4 > 2147483647L) {
		throw new IllegalArgumentException("Size exceeds Integer.MAX_VALUE");
	} else {
		byte var6 = -1;
		if (var1 == MapMode.READ_ONLY) {
			var6 = 0;
		} else if (var1 == MapMode.READ_WRITE) {
			var6 = 1;
		} else if (var1 == MapMode.PRIVATE) {
			var6 = 2;
		}

		assert var6 >= 0;

		if (var1 != MapMode.READ_ONLY && !this.writable) {
			throw new NonWritableChannelException();
		} else if (!this.readable) {
			throw new NonReadableChannelException();
		} else {
			long var7 = -1L;
			int var9 = -1;

			MappedByteBuffer var37;
			try {
				this.begin();
				var9 = this.threads.add();
				if (!this.isOpen()) {
					Object var34 = null;
					return (MappedByteBuffer)var34;
				}

				long var10;
				int var12;
				synchronized(this.positionLock) {
					long var14;
					do {
						var14 = this.nd.size(this.fd);
					} while(var14 == -3L && this.isOpen());

					if (!this.isOpen()) {
						var37 = null;
						return var37;
					}

					MappedByteBuffer var17;
					if (var14 < var2 + var4) {
						if (!this.writable) {
							throw new IOException("Channel not open for writing - cannot extend file to required size");
						}

						int var16;
						do {
							var16 = this.nd.truncate(this.fd, var2 + var4);
						} while(var16 == -3 && this.isOpen());

						if (!this.isOpen()) {
							var17 = null;
							return var17;
						}
					}

					if (var4 == 0L) {
						var7 = 0L;
						FileDescriptor var38 = new FileDescriptor();
						if (this.writable && var6 != 0) {
							var17 = Util.newMappedByteBuffer(0, 0L, var38, (Runnable)null);
							return var17;
						}

						var17 = Util.newMappedByteBufferR(0, 0L, var38, (Runnable)null);
						return var17;
					}

					var12 = (int)(var2 % allocationGranularity);
					long var36 = var2 - (long)var12;
					var10 = var4 + (long)var12;

					try {
						var7 = this.map0(var6, var36, var10);
					} catch (OutOfMemoryError var31) {
						System.gc();

						try {
							Thread.sleep(100L);
						} catch (InterruptedException var30) {
							Thread.currentThread().interrupt();
						}

						try {
							var7 = this.map0(var6, var36, var10);
						} catch (OutOfMemoryError var29) {
							throw new IOException("Map failed", var29);
						}
					}
				}

				FileDescriptor var13;
				try {
					var13 = this.nd.duplicateForMapping(this.fd);
				} catch (IOException var28) {
					unmap0(var7, var10);
					throw var28;
				}

				assert IOStatus.checkAll(var7);

				assert var7 % allocationGranularity == 0L;

				int var35 = (int)var4;
				FileChannelImpl.Unmapper var15 = new FileChannelImpl.Unmapper(var7, var10, var35, var13);
				if (!this.writable || var6 == 0) {
					var37 = Util.newMappedByteBufferR(var35, var7 + (long)var12, var13, var15);
					return var37;
				}

				var37 = Util.newMappedByteBuffer(var35, var7 + (long)var12, var13, var15);
			} finally {
				this.threads.remove(var9);
				this.end(IOStatus.checkAll(var7));
			}

			return var37;
		}
	}
}

上述代码可以看出，最终map通过native函数map0完成文件的映射工作。

  • 1、如果第一次文件映射导致OOM，则手动触发垃圾回收，休眠100ms后再次尝试映射，如果失败，则抛出异常。
  • 2、通过newMappedByteBuffer方法初始化MappedByteBuffer实例，不过其最终返回的是DirectByteBuffer的实例，实现如下：
static MappedByteBuffer newMappedByteBuffer(int var0, long var1, FileDescriptor var3, Runnable var4) {
	if (directByteBufferConstructor == null) {
		initDBBConstructor();
	}

	try {
		MappedByteBuffer var5 = (MappedByteBuffer)directByteBufferConstructor.newInstance(new Integer(var0), new Long(var1), var3, var4);
		return var5;
	} catch (IllegalAccessException | InvocationTargetException | InstantiationException var7) {
		throw new InternalError(var7);
	}
}


// 访问权限
private static void initDBBConstructor() {
	AccessController.doPrivileged(new PrivilegedAction<Void>() {
		public Void run() {
			try {
				Class var1 = Class.forName("java.nio.DirectByteBuffer");
				Constructor var2 = var1.getDeclaredConstructor(Integer.TYPE, Long.TYPE, FileDescriptor.class, Runnable.class);
				var2.setAccessible(true);
				Util.directByteBufferConstructor = var2;
				return null;
			} catch (NoSuchMethodException | IllegalArgumentException | ClassCastException | ClassNotFoundException var3) {
				throw new InternalError(var3);
			}
		}
	});
}

由于FileChannelImpl和DirectByteBuffer不在同一个包中，所以有权限访问问题，通过AccessController类获取DirectByteBuffer的构造器进行实例化。

DirectByteBuffer是MappedByteBuffer的一个子类，其实现了对内存的直接操作。

get过程

MappedByteBuffer的get方法最终通过DirectByteBuffer.get方法实现的。

public long address() {
	return address;
}

private long ix(int i) {
	return address + ((long)i << 0);
}

public byte get() {
	return ((unsafe.getByte(ix(nextGetIndex()))));
}

public byte get(int i) {
	return ((unsafe.getByte(ix(checkIndex(i)))));
}

map0()函数返回一个地址address，这样就无需调用read或write方法对文件进行读写，通过address就能够操作文件。底层采用unsafe.getByte方法，通过（address + 偏移量）获取指定内存的数据。

  • 1、第一次访问address所指向的内存区域，导致缺页中断，中断响应函数会在交换区中查找相对应的页面，如果找不到（也就是该文件从来没有被读入内存的情况），则从硬盘上将文件指定页读取到物理内存中（非jvm堆内存）。

  • 2、如果在拷贝数据时，发现物理内存不够用，则会通过虚拟内存机制（swap）将暂时不用的物理页面交换到硬盘的虚拟内存中。

性能分析

从代码层面上看，从硬盘上将文件读入内存，都要经过文件系统进行数据拷贝，并且数据拷贝操作是由文件系统和硬件驱动实现的，理论上来说，拷贝数据的效率是一样的。 但是通过内存映射的方法访问硬盘上的文件，效率要比read和write系统调用高，这是为什么？

  • read()是系统调用，首先将文件从硬盘拷贝到内核空间的一个缓冲区，再将这些数据拷贝到用户空间，实际上进行了两次数据拷贝。

  • map()也是系统调用，但没有进行数据拷贝，当缺页中断发生时，直接将文件从硬盘拷贝到用户空间，只进行了一次数据拷贝。

所以，采用内存映射的读写效率要比传统的read/write性能高。

总结

  • 1、MappedByteBuffer使用虚拟内存，因此分配(map)的内存大小不受JVM的-Xmx参数限制，但是也是有大小限制的。

  • 2、如果当文件超出1.5G限制时，可以通过position参数重新map文件后面的内容。

  • 3、MappedByteBuffer在处理大文件时的确性能很高，但也存在一些问题，如内存占用、文件关闭不确定，被其打开的文件只有在垃圾回收的才会被关闭，而且这个时间点是不确定的。

javadoc中也提到：A mapped byte buffer and the file mapping that it represents remain valid until the buffer itself is garbage-collected.*

 

参考： https://blog.csdn.net/qq_41969879/article/details/81629469

举报

相关推荐

java NIO之MappedByteBuffer

RandomAccessFileMappedByteBufferjava数据io操作Java编程语言

Java NIO MappedByteBuffer 作用：让文件在堆外内存做修改

java

java: MappedByteBuffer的用法

javapython开发语言HarmonyOS后端开发

java nio

java nio.netjavahtml虚拟化云计算

Java NIO

java数据字符流

Java NIO系列教程（一） Java NIO 概述

java网络Java单线程数据JavaScript前端开发

Java NIO、NIO.2学习笔记

javaSystem数据系统/运维

JAVA IO:NIO

hadoop大数据分布式

Java NIO用法

javaSystem数据Python后端开发

Java NIO概念

javanio开发语言
0 条评论