Java的readBytes是怎么实现的？

1.前言

众所周知，Java是一门跨平台语言，针对不同的操作系统有不同的实现。本文从一个非常简单的api调用来看看Java具体是怎么做的.
2.源码分析

从FileInputStream.java中看到readBytes最后是native调用

1. /**
2.      * Reads a subarray as a sequence of bytes.
3.      * @param b the data to be written
4.      * @param off the start offset in the data
5.      * @param len the number of bytes that are written
6.      * @exception IOException If an I/O error has occurred.
7.      */
8.     private native int readBytes(byte b[], int off, int len) throws IOException; // native调用
10.     /**
11.      * Reads up to b.length bytes of data from this input
12.      * stream into an array of bytes. This method blocks until some input
13.      * is available.
14.      *
15.      * @param      b   the buffer into which the data is read.
16.      * @return     the total number of bytes read into the buffer, or
17.      *             -1 if there is no more data because the end of
18.      *             the file has been reached.
19.      * @exception  IOException  if an I/O error occurs.
20.      */
21.     public int read(byte b[]) throws IOException {
22.         return readBytes(b, 0, b.length);
23.     }

复制代码

从jdk源码中，我们找到FileInputStream.c(/jdk/src/share/native/java/io)，此文件定义了对应文件的native调用.

1. // FileInputStream.c
3. JNIEXPORT jint JNICALL
4. Java_java_io_FileInputStream_readBytes(JNIEnv *env, jobject this,
5.         jbyteArray bytes, jint off, jint len) {
6.     return readBytes(env, this, bytes, off, len, fis_fd);
7. }

复制代码

我们观察下当前的目录，可以看到java 对典型的四种unix like的系统（bsd, linux, macosx, solaris）， 以及windows 提供了特殊实现。share是公用部分。

在头部获取文件fd field （fd 是非负正整数，用来标识打开文件）

1. // FileInputStream.c
3. JNIEXPORT void JNICALL
4. Java_java_io_FileInputStream_initIDs(JNIEnv *env, jclass fdClass) {
5.     fis_fd = (*env)->GetFieldID(env, fdClass, "fd", "Ljava/io/FileDescriptor;"); /* fd field，后面用来获取 fd */
6. }

复制代码

 继续调用readBytes

1. // ioutil.c
3. jint
4. readBytes(JNIEnv *env, jobject this, jbyteArray bytes,
5.           jint off, jint len, jfieldID fid)
6. {
7.     jint nread;
8.     char stackBuf[BUF_SIZE];
9.     char *buf = NULL;
10.     FD fd;
12.     if (IS_NULL(bytes)) {
13.         JNU_ThrowNullPointerException(env, NULL);
14.         return -1;
15.     }
17.     if (outOfBounds(env, off, len, bytes)) { /* 越界判断 */
18.         JNU_ThrowByName(env, "java/lang/IndexOutOfBoundsException", NULL);
19.         return -1;
20.     }
22.     if (len == 0) {
23.         return 0;
24.     } else if (len > BUF_SIZE) {
25.         buf = malloc(len); /* 缓冲区不足，动态分配内存 */
26.         if (buf == NULL) {
27.             JNU_ThrowOutOfMemoryError(env, NULL);
28.             return 0;
29.         }
30.     } else {
31.         buf = stackBuf;
32.     }
34.     fd = GET_FD(this, fid); /* 获取fd */
35.     if (fd == -1) {
36.         JNU_ThrowIOException(env, "Stream Closed");
37.         nread = -1;
38.     } else {
39.         nread = IO_Read(fd, buf, len); /* 执行read，系统调用 */
40.         if (nread > 0) {
41.             (*env)->SetByteArrayRegion(env, bytes, off, nread, (jbyte *)buf);
42.         } else if (nread == -1) {
43.             JNU_ThrowIOExceptionWithLastError(env, "Read error");
44.         } else { /* EOF */
45.             nread = -1;
46.         }
47.     }
49.     if (buf != stackBuf) {
50.         free(buf); /* 失败释放内存 */
51.     }
52.     return nread;
53. }

复制代码

我们继续看看IO_Read的实现，是个宏定义
#define IO_Read handleReadhandleRead有两种实现
solaris实现：

1. // /jdk/src/solaris/native/java/io/io_util_md.c
3. ssize_t
4. handleRead(FD fd, void *buf, jint len)
5. {
6.     ssize_t result;
7.     RESTARTABLE(read(fd, buf, len), result);
8.     return result;
9. }
11. /*
12. * Retry the operation if it is interrupted
13. */
14. #define RESTARTABLE(_cmd, _result) do { \
15.     do { \
16.         _result = _cmd; \
17.     } while((_result == -1) && (errno == EINTR)); \ /* 如果是中断，则不断重试，避免进程调度等待*/
18. } while(0)

复制代码

read方法可以参考unix man page
windows实现：

1. // jdk/src/windows/native/java/io/io_util_md.c
3. JNIEXPORT
4. jint
5. handleRead(FD fd, void *buf, jint len)
6. {
7.     DWORD read = 0;
8.     BOOL result = 0;
9.     HANDLE h = (HANDLE)fd;
10.     if (h == INVALID_HANDLE_VALUE) {
11.         return -1;
12.     }
13.     result = ReadFile(h,          /* File handle to read */
14.                       buf,        /* address to put data */
15.                       len,        /* number of bytes to read */
16.                       &read,      /* number of bytes read */
17.                       NULL);      /* no overlapped struct */
18.     if (result == 0) {
19.         int error = GetLastError();
20.         if (error == ERROR_BROKEN_PIPE) {
21.             return 0; /* EOF */
22.         }
23.         return -1;
24.     }
25.     return (jint)read;
26. }

复制代码

3.java异常初探

1. // jdk/src/share/native/common/jni_util.c
3. /**
4. * Throw a Java exception by name. Similar to SignalError.
5. */
6. JNIEXPORT void JNICALL
7. JNU_ThrowByName(JNIEnv *env, const char *name, const char *msg)
8. {
9.     jclass cls = (*env)->FindClass(env, name);
11.     if (cls != 0) /* Otherwise an exception has already been thrown */
12.         (*env)->ThrowNew(env, cls, msg); /* 调用JNI 接口*/
13. }
15. /* JNU_Throw common exceptions */
17. JNIEXPORT void JNICALL
18. JNU_ThrowNullPointerException(JNIEnv *env, const char *msg)
19. {
20.     JNU_ThrowByName(env, "java/lang/NullPointerException", msg);
21. }

复制代码

最后是调用JNI:

1. // hotspot/src/share/vm/prims/jni.h
3. jint ThrowNew(jclass clazz, const char *msg) {
4.         return functions->ThrowNew(this, clazz, msg);
5.     }
7. jint (JNICALL *ThrowNew)
8.       (JNIEnv *env, jclass clazz, const char *msg);

复制代码

4.总结

很多高级语言，有着不同的编程范式，但是归根到底还是（c语言）系统调用，c语言能够在更低的层面做非常多的优化。如果我们了解了这些底层的系统调用，就能看到问题的本质。
本文没有对JNI 做深入分析，后续继续解析。
5.参考

https://man7.org/linux/man-pages/man2/read.2.html

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！