一、前言
也许你见过下面这样一段代码。
File file = new File("file-map-sample.txt");
file.delete();
file.createNewFile();
RandomAccessFile randomAccessFile = new RandomAccessFile(file,"rw");
FileChannel fileChannel = randomAccessFile.getChannel();
MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE,0,Integer.MAX_VALUE);
System.out.println("MappedByteBuffer capacity " + mappedByteBuffer.capacity());
long currentTime = System.currentTimeMillis();
int size = Integer.MAX_VALUE / 4;
for (int i = 0; i < size; i++) {
mappedByteBuffer.putInt(i);
}
mappedByteBuffer.force();
fileChannel.close();
randomAccessFile.close();
System.out.println("MappedByteBuffer Write " + (System.currentTimeMillis() - currentTime) + " ms");
通过 Java NIO 中的文件映射进行写文件。关于 NIO 大部分同学应该知道有这么个东西，但好像又不怎么熟悉，因为平时要用到的地方可能真的不太多吧。
二、关于 Java NIO
好吧，Java NIO 是 Java New IO。是 JDK 1.4 开始提供的一套新的可用来代替原 Java IO 的接口。然而这么多年过去了，结果并木有。
Java NIO.jpg
这里看到了 Java NIO 中的核心概念：Channel，Buffer 以及 selector。关于 Java NIO 的更详细的说明，可参考
三、原理探索
不管是 NIO 还是 IO，都需要 new 一个 File***Stream 或者 RandomAccessFile 从而获取它的 FileChannel。而在这之前，我们需要弄明白一些事情。当我们 new 一个流对象时究竟发生了什么？与之密切相关的 FileDescriptor 又是什么？它与 Channel 之间有着怎么样的联系？
3.1 探究 FileDescriptor
这里先看一个简单的类图，在心里有一个简单的地图。
FileChannel.jpg
这里为了简单起见，以 new 一个 FileInputStream 为例。
public FileInputStream(File file) throws FileNotFoundException {
......
154 fd = new FileDescriptor();
155
......
165 open(name);
166
......
169 }
去掉校验和 BlockGuard 相关的代码，FileInputStream 的构造方法简化下来还有 2 个步骤，new 一个 FileDescriptor 对象 和 open() 文件。先来看看 FileDescriptor。
public /**/ FileDescriptor() {
62 descriptor = -1;
63 }
默认为 -1，这个是虚晃一枪。肯定得有地方给它真正的值。我想，应该是 open() 里面。不过 open() 是调用的 native 方法 open0()。所以需要进一步看 open0() 的实现。这里需要看到 FileInputStream 的 native 代码 FileInputStream.c 中对于 open0 的实现。
66 FileInputStream_open0(JNIEnv *env, jobject this, jstring path) {
67 fileOpen(env, this, path, fis_fd, O_RDONLY);
68}
open0() 进一步调用了函数 fileOpen()。注意这里的第 4 个参数 fis_fd。它是 Java 层 fd 在 native 层的 fieldId。可以看看它的定义和初始化，就会一目了然了。
jfieldID fis_fd; /* id for jobject 'fd' in java.io.FileInputStream */
60static void FileInputStream_initIDs(JNIEnv *env) {
61 jclass clazz = (*env)->FindClass(env, "java/io/FileInputStream");
62 fis_fd = (*env)->GetFieldID(env, clazz, "fd", "Ljava/io/FileDescriptor;");
63}
接着继续看 fileOpen() 函数，它在 io_util_md.c 中定义。
88void
89fileOpen(JNIEnv *env, jobject this, jstring path, jfieldID fid, int flags)
90{
91 WITH_PLATFORM_STRING(env, path, ps) {
92 FD fd;
93
......
100 fd = handleOpen(ps, flags, 0666);
101 if (fd != -1) {
102 SET_FD(this, fd, fid);
103 } else {
104 throwFileNotFoundException(env, path);
105 }
106 } END_PLATFORM_STRING(env, ps);
107}
这里看到了 FD 的定义，不过它只不过是一个宏定义而已，原型就是 jint。那这个函数所做的事情就是打开文件获得 fd，然后通过宏定义 SET_FD 赋值给 Java 层的 fd 对象中的 descriptor。对，这是个结论，我们来看看具体的实现过程。先看 handleOpen()。
65 FD
66 handleOpen(const char *path, int oflag, int mode) {
67 FD fd;
68 RESTARTABLE(open64(path, oflag, mode), fd);
......
84 return fd;
85}
open64() 是一个宏定义，指向 open() 函数。RESTARTABLE 也是一个宏定义，其就是将前面的参数结果赋值给后面的参数。那么，这里就是将 open() 函数的返回结果文件描述符 FD 赋值给 fd。
通过上述 handleOpen() 就打开了文件，并且返回了文件的描述符，而如果文件描述符为 -1 的话那就会抛出著名的 exception —— FileNotFoundException。然后再来看看
49#define SET_FD(this, fd, fid) \
50 if ((*env)->GetObjectField(env, (this), (fid)) != NULL) \
51 (*env)->SetIntField(env, (*env)->GetObjectField(env, (this), (fid)),IO_fd_fdID, (fd))
这里的 (*env)->GetObjectField(env, (this), (fid)) 就是获取 FileInputStream 的 fd 属性，而 IO_fd_fdID 就是其属性的属性 descriptor，代码如下。
IO_fd_fdID = (*env)->GetFieldID(env, fdClass, "descriptor", "I");
至此，就分析完了文件的打开与文件描述符 FD 了。当我们 new 一个 FileInputStream 的时候，其实底层是调用了函数 open()，并且返回了一个文件描述符 fd，而后对文件的所有操作其实都是作用在这个 fd 之上的。
3.2 探究 FileChannel
在 new 完 FileInputStream 后，可以通过其 getChannel() 方法获得一个 FileChannel 对象。从上面的类图中可知，FileChannel 是一个抽象类，真正的实现类在 FileChannelImpl。FileChannelImpl 中有 2 个核心属性分别是 fd 和 nd。fd 好理解，就是 FileDescriptor。而 nd 是 FileDispatcherImpl，字面意思 “文件分发”？还是一起来看看吧。再回到 FileInputStream.getChannel() 看看是如何获得 FileChannel 的。
456 public FileChannel getChannel() {
457 synchronized (this) {
458 if (channel == null) {
459 channel = FileChannelImpl.open(fd, path, true, false, this);
460 }
461 return channel;
462 }
463 }
FileChannelImpl 的构造函数是私有的，只能通过其静态方法 open() 来构造，而这里传入的参数依次是文件描述符 fd，路径，可读，可写(inputstream 不可写)，FileInputStream。在 open() 方法中，就是直接 new 一个 FileChannelImple 对象。那来看看它的构造方法。
98 private FileChannelImpl(FileDescriptor fd, String path, boolean readable,
99 boolean writable, boolean append, Object parent)
100 {
101 this.fd = fd;
102 this.readable = readable;
103 this.writable = writable;
104 this.append = append;
105 this.parent = parent;
106 this.path = path;
107 this.nd = new FileDispatcherImpl(append);
112 }
前面几个属性都是基本的赋值操作，主要需要进一步分析 FileDispatcherImpl。
43 FileDispatcherImpl(boolean append) {
44 /* append is ignored */
45 }
呃，什么都没有，......
看到这里，就有点懵了，还是没明白 FileChannel 是个什么东西。不过还是可以总结下就是，其有两个核心的属性 fd 和 nd，看起来 FileChannel 对 Buffer 的读写操作应该是通过 nd 来实现的，nd 操作的也必将是 fd 。
前面有说过 Channel 是 NIO 的核心之一，那除了 FileChannel，还有......看看类图吧。
Channel.jpg
3.3 探究 Buffer
先来看一看 Buffer 的类图结构。
Buffer.jpg
Buffer 确实就是缓冲区，上图中，顶级父类 Buffer 下可以看成左边 ByteBuffer 和右边其他类型的 Buffer。其实只存在 ByteBuffer，其他类型 Buffer 都是为了方便操作而言的。而 ByteBuffer 从内存的角度来看又分为 HeapByteBuffer 和 DirectedByteBuffer，详细如下图。
ByteBuffer.jpg
这里可能需要注意一下的是，在 Android 中和在 Java 中，它们的实现是有差异的。另外，如果之前有熟悉的 okio 的同学，看到这里应该更加不会陌生。当然，你现在也可以去看一看，okio 也是充分运用了缓冲来读写数据，以提高IO性能的。Okio深入分析—源码分析部分
3.4 从 Channel 读数据到 Buffer
- Buffer 的初始化
这里假设我们是直接从 Java 堆内存分配 Buffer 的空间，也就是我们是通过 ByteBuffer.allocate(1024) 初始化的 Buffer。这里还是看一看代码，有个印象。
278 public static ByteBuffer allocate(int capacity) {
279 if (capacity < 0)
280 throw new IllegalArgumentException();
281 return new HeapByteBuffer(capacity, capacity);
282 }
53 private HeapByteBuffer(int cap, int lim, boolean isReadOnly) {
54 super(-1, 0, lim, cap, new byte[cap], 0);
55 this.isReadOnly = isReadOnly;
56 }
初始化完成后，状态如下。
Buffer 初始化.jpg
- 读取 512 个字节到 Buffer
fileChannel.read(byteBuffer);
将数据写入到了 Buffer 后，Buffer 的状态如下。
Buffer 写入512.jpg
- read() 方法的实现
181 public int read(ByteBuffer dst) throws IOException {
182 ensureOpen();
183 if (!readable)
184 throw new NonReadableChannelException();
185 synchronized (positionLock) {
186 int n = 0;
187 int ti = -1;
188 try {
189 begin();
190 ti = threads.add();
191 if (!isOpen())
192 return 0;
193 do {
194 n = IOUtil.read(fd, dst, -1, nd);
195 } while ((n == IOStatus.INTERRUPTED) && isOpen());
196 return IOStatus.normalize(n);
197 } finally {
198 threads.remove(ti);
199 end(n > 0);
200 assert IOStatus.check(n);
201 }
202 }
203 }
下图是这段代码主要做的事情。
Read Buffer.jpg
四、总结
关于 Java NIO 的探索就先到这里了，其本身的实现还是较为复杂的。尤其是对于非阻塞的实现，功力实在尚浅暂时没有分析的很清楚。
最后，感谢你能读到此文章。如果我的分享对你有帮忙，还请帮忙点个赞。谢谢。
网友评论