Java中Memory Mapped File原理分析

/**
 * @author Shuai Junlan[shuaijunlan@gmail.com].
 * @since Created in 3:03 PM 12/8/18.
 */
public class MmapTest {
    public static void main(String[] args) throws IOException {
        File file = new File("test.txt");
        assert file.exists() || file.createNewFile();
        FileChannel channel = new RandomAccessFile(file, "rw").getChannel();
        MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 1000);
        for (int i = 0; i < 1000; i++){
            mappedByteBuffer.put((byte)i);
        }
        mappedByteBuffer.position(0);
        for (int i = 0; i < 1000; i++){
            System.out.println(mappedByteBuffer.get());
        }
    }
}

public final FileChannel getChannel() {
    synchronized (this) {
        if (channel == null) {
            channel = FileChannelImpl.open(fd, path, true, rw, this);
        }
        return channel;
    }
}

  public MappedByteBuffer map(MapMode mode, long position, long size)
      throws IOException
  {
//省略参数检查

      long addr = -1;
      int ti = -1;
      try {
          begin();
          ti = threads.add();
          if (!isOpen())
              return null;

          long mapSize;
          int pagePosition;
          //加锁，保证线程安全
          synchronized (positionLock) {
              long filesize;
              do {
                  filesize = nd.size(fd);
              } while ((filesize == IOStatus.INTERRUPTED) && isOpen());
              if (!isOpen())
                  return null;
		//如果映射范围超出文件的大小且不可写，则抛出异常
              if (filesize < position + size) { // Extend file size
                  if (!writable) {
                      throw new IOException("Channel not open for writing " +
                          "- cannot extend file to required size");
                  }
                  int rv;
                  //填充文件
                  do {
                      rv = nd.allocate(fd, position + size);
                  } while ((rv == IOStatus.INTERRUPTED) && isOpen());
                  if (!isOpen())
                      return null;
              }

              pagePosition = (int)(position % allocationGranularity);
              long mapPosition = position - pagePosition;
              mapSize = size + pagePosition;
              try {
                  // If map0 did not throw an exception, the address is valid
                  addr = map0(imode, mapPosition, mapSize);
              } catch (OutOfMemoryError x) {
                  // An OutOfMemoryError may indicate that we've exhausted
                  // memory so force gc and re-attempt map
                  System.gc();
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException y) {
                      Thread.currentThread().interrupt();
                  }
                  try {
                      addr = map0(imode, mapPosition, mapSize);
                  } catch (OutOfMemoryError y) {
                      // After a second OOME, fail
                      throw new IOException("Map failed", y);
                  }
              }
          } // synchronized

          // On Windows, and potentially other platforms, we need an open
          // file descriptor for some mapping operations.
          FileDescriptor mfd;
          try {
              mfd = nd.duplicateForMapping(fd);
          } catch (IOException ioe) {
              unmap0(addr, mapSize);
              throw ioe;
          }

          assert (IOStatus.checkAll(addr));
          assert (addr % allocationGranularity == 0);
          int isize = (int)size;
          Unmapper um = new Unmapper(addr, mapSize, isize, mfd);
          if ((!writable) || (imode == MAP_RO)) {
              return Util.newMappedByteBufferR(isize,
                                               addr + pagePosition,
                                               mfd,
                                               um);
          } else {
              return Util.newMappedByteBuffer(isize,
                                              addr + pagePosition,
                                              mfd,
                                              um);
          }
      } finally {
          threads.remove(ti);
          end(IOStatus.checkAll(addr));
      }
  }

static MappedByteBuffer newMappedByteBuffer(int size, long addr,
                                            FileDescriptor fd,
                                            Runnable unmapper)
{
    MappedByteBuffer dbb;
    if (directByteBufferConstructor == null)
        initDBBConstructor();
    try {
        dbb = (MappedByteBuffer)directByteBufferConstructor.newInstance(
            new Object[] { new Integer(size),
                          new Long(addr),
                          fd,
                          unmapper });
    } catch (InstantiationException |
             IllegalAccessException |
             InvocationTargetException e) {
        throw new InternalError(e);
    }
    return dbb;
}

private static void initDBBRConstructor() {
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
            try {
                Class<?> cl = Class.forName("java.nio.DirectByteBufferR");
                Constructor<?> ctor = cl.getDeclaredConstructor(
                    new Class<?>[] { int.class,
                                    long.class,
                                    FileDescriptor.class,
                                    Runnable.class });
                ctor.setAccessible(true);
                directByteBufferRConstructor = ctor;
            } catch (ClassNotFoundException |
                     NoSuchMethodException |
                     IllegalArgumentException |
                     ClassCastException x) {
                throw new InternalError(x);
            }
            return null;
        }});
}

public byte get() {
    return ((unsafe.getByte(ix(nextGetIndex()))));
}
public ByteBuffer put(byte x) {
    unsafe.putByte(ix(nextPutIndex()), ((x)));
    return this;
}