一、序言
IO操作，才程序中比较普遍，JAVA 中提出了IO/NIO 的概念，也一直在说NIO 比IO快，一直不知道原因，就想memcache 和ehcache 比较优劣一样，这些东西得自己看看如何实现的，才 知道区别，从而才知道优劣以及试用范围，而不仅仅是“听说”！这里我可以先了解下JAVA 如何操作IO的。
二、代码示例
我们先看看简单文件操作：
// 这是将文件转换成输入流的的一种方式，获得了流我们就能干很多事
FileInputStream in = new FileInputStream(new File("...file"));
再看看FileInputStream 的源码：
public FileInputStream(File file) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
// 安全管理器，这里暂时不说
SecurityManager security = System.getSecurityManager();
if (security != null) {
// 检查是否可以按这名字读取
security.checkRead(name);
}
if (name == null) {
throw new NullPointerException();
}
// 获得文件描述，这个JDK 未公布
fd = new FileDescriptor();
// 打开文件，这是个native 方法，我们可以用openjdk 看看里面
open(name);
}
在FileInputStream.c下可以找到方法
// open 方法
JNIEXPORT void JNICALL
Java_java_io_FileInputStream_open(JNIEnv *env, jobject this, jstring path) {
fileOpen(env, this, path, fis_fd, O_RDONLY);
}
OK。我们从该文件上面的引用io_util_md.c找到实现：
void
fileOpen(JNIEnv *env, jobject this, jstring path, jfieldID fid, int flags)
{
jlong h = winFileHandleOpen(env, path, flags);
if (h >= 0) {
// 设置fd 的值
SET_FD(this, h, fid);
}
}
在上面文件里面可以看到：winFileHandleOpen，
jlong
winFileHandleOpen(JNIEnv *env, jstring path, int flags)
{
const DWORD access =
(flags & O_RDWR) ? (GENERIC_WRITE | GENERIC_READ) :
(flags & O_WRONLY) ? GENERIC_WRITE :
GENERIC_READ;
const DWORD sharing =
FILE_SHARE_READ | FILE_SHARE_WRITE;
const DWORD disposition =
/* Note: O_TRUNC overrides O_CREAT */
(flags & O_TRUNC) ? CREATE_ALWAYS :
(flags & O_CREAT) ? OPEN_ALWAYS :
OPEN_EXISTING;
const DWORD maybeWriteThrough =
(flags & (O_SYNC | O_DSYNC)) ?
FILE_FLAG_WRITE_THROUGH :
FILE_ATTRIBUTE_NORMAL;
const DWORD maybeDeleteOnClose =
(flags & O_TEMPORARY) ?
FILE_FLAG_DELETE_ON_CLOSE :
FILE_ATTRIBUTE_NORMAL;
const DWORD flagsAndAttributes = maybeWriteThrough | maybeDeleteOnClose;
HANDLE h = NULL;
if (onNT) {
WCHAR *pathbuf = pathToNTPath(env, path, JNI_TRUE);
if (pathbuf == NULL) {
/* Exception already pending */
return -1;
}
h = CreateFileW(
pathbuf, /* Wide char path name */
access, /* Read and/or write permission */
sharing, /* File sharing flags */
NULL, /* Security attributes */
disposition, /* creation disposition */
flagsAndAttributes, /* flags and attributes */
NULL);
free(pathbuf);
} else {
WITH_PLATFORM_STRING(env, path, _ps) {
h = CreateFile(_ps, access, sharing, NULL, disposition,
flagsAndAttributes, NULL);
} END_PLATFORM_STRING(env, _ps);
}
if (h == INVALID_HANDLE_VALUE) {
int error = GetLastError();
if (error == ERROR_TOO_MANY_OPEN_FILES) {
JNU_ThrowByName(env, JNU_JAVAIOPKG "IOException",
"Too many open files");
return -1;
}
throwFileNotFoundException(env, path);
return -1;
}
return (jlong) h;
}
好吧，上面代码我也搞不明白- -，但是这几句代码：
h = CreateFileW(
pathbuf, /* Wide char path name */
access, /* Read and/or write permission */
sharing, /* File sharing flags */
NULL, /* Security attributes */
disposition, /* creation disposition */
flagsAndAttributes, /* flags and attributes */
NULL);
以及
WITH_PLATFORM_STRING(env, path, _ps) {
h = CreateFile(_ps, access, sharing, NULL, disposition,
flagsAndAttributes, NULL);
我的理解是，这里通过CreateFileW方法，创建了一个类似文件描述的结构，然后通过CreateFile调windows 下面的底层方法，填充这个结构的数据，那么这个文件对象就能被我们上层对象识别了，就能是获取里面的资源。
OK，我们现在创建了对文件之间的连接，拿到文件流对象之后，来看看我们常用的read 方法。
// 对字节的操作 public native int read() throws IOException; private native int readBytes(byte b[], int off, int len) throws IOException;
在FileInputStream.c 里面同样可以找到
JNIEXPORT jint JNICALL
Java_java_io_FileInputStream_read(JNIEnv *env, jobject this) {
return readSingle(env, this, fis_fd);
}
JNIEXPORT jint JNICALL
Java_java_io_FileInputStream_readBytes(JNIEnv *env, jobject this,
jbyteArray bytes, jint off, jint len) {
return readBytes(env, this, bytes, off, len, fis_fd);
}
继续看io_util.c 里面：
jint
readSingle(JNIEnv *env, jobject this, jfieldID fid) {
jint nread;
char ret;
FD fd = GET_FD(this, fid);
if (fd == -1) {
JNU_ThrowIOException(env, "Stream Closed");
return -1;
}
// 看出是一个一个的读取，fd 表示刚才文件描述的一种结构
nread = IO_Read(fd, &ret, 1);
if (nread == 0) { /* EOF */
return -1;
} else if (nread == JVM_IO_ERR) { /* error */
JNU_ThrowIOExceptionWithLastError(env, "Read error");
} else if (nread == JVM_IO_INTR) {
JNU_ThrowByName(env, "java/io/InterruptedIOException", NULL);
}
return ret & 0xFF;
}
关于IO_Read 的东西，在io_util_md.h 有定义：
/* * HPI是一个与主机通信的并行接口 * Route the routines through HPI */ #define IO_Write JVM_Write #define IO_Sync JVM_Sync #define IO_Read JVM_Read #define IO_Lseek JVM_Lseek #define IO_Available JVM_Available #define IO_SetLength JVM_SetLength
关于JVM_Read 我在jvm.h 里面看到
/* // 从文件里面读取 a char array * Read data from a file decriptor into a char array. * // 文件的来源 * fd the file descriptor to read from. // 读出来的存放位置 * buf the buffer where to put the read data. // 读的字节数 * nbytes the number of bytes to read. * * This function returns -1 on error, and 0 on success. */ JNIEXPORT jint JNICALL JVM_Read(jint fd, char *buf, jint nbytes);
然后在jvm.cpp 里面找到
关于这段代码，大神告诉我是宏定义，关于C和C++ 的东西，我已经无力回天啦。
当然我们知道了介绍，可以理解这里会让调系统的read 方法。
这可以参考：“操作系统read 的原理实现”，google 一下很多，这里就不解释了
jvm.cpp 里面有很多关于IO这块的，可以去看看，但是都是 宏定义。。
关于linux 下的这些代码，还有涉及一下阻塞等东西，以后在去研究一下操作系统的东西吧。
JVM_LEAF(jint, JVM_Read(jint fd, char *buf, jint nbytes))
JVMWrapper2("JVM_Read (0x%x)", fd);
//%note jvm_r6
return (jint)os::restartable_read(fd, buf, nbytes);
JVM_END
小结：
1.本想了解下底层怎么操作的，但是大概了解下了，最终到read 或者write 的时候，一些基础知识不够，还是不能透彻，但是也足够我们大致了解了。
2.按上面的思路可以看出大概的思路，虽然没写write 的过程，但是最终都是通过流，或者说字符数组在内存里面的一些操作进行，包括我们用装饰器模式搞了很多其他流，基本原理一样，仅仅为了方便加了额外的功能。
3. 有不对的地方还请指出，仅仅是个人学习，分享作用