How JVM access the file system

Question

Hi there,

I have an argument with my boss who is convinced that the JVM uses JNI to access native things like the file system. I think he is wrong because the JVM itself is a native code and it communicates directly with the OS - it doesn't need the JNI boilerplate to access the file system.

Please help me to clarify how the JVM works

Thanks in advance, Rosen

Answer 1

JNI is for Java code to access native code. You are correct, the JVM IS Native code so it is directly tied to the platform it is compiled for. That is why there is a JVM for each Operating System. The Windows JVM is compiled for Windows, Linux for Linux, OSX for OSX, etc. They have all the platform specific code baked into the JVM code itself.

Answer 2

This is a bit of a moot point really. Java Native Interfaces are a language feature to allow you to define a function call in Java that will be passed out to code that is non-java, specifically, native to the platform. If you take a look at FileOutputStream.java in the src.zip of your SDK, you'll see code like this:

    /**
 * Opens a file, with the specified name, for writing.
 * @param name name of file to be opened
 */
private native void open(String name) throws FileNotFoundException;

/**
 * Opens a file, with the specified name, for appending.
 * @param name name of file to be opened
 */
private native void openAppend(String name) throws FileNotFoundException;

/**
 * Writes the specified byte to this file output stream. Implements 
 * the <code>write</code> method of <code>OutputStream</code>.
 *
 * @param      b   the byte to be written.
 * @exception  IOException  if an I/O error occurs.
 */
public native void write(int b) throws IOException;

So I would say if the question is - does the class library use the same notation I do to access external system-level library calls I think the answer would be yes.

However, the Java Virtual Machine that interprets java bytecode and applies these rules is definitely native code - I suspect also that for the sake of naming (different "native" systems use totally different APIs) unlike native calls direct to libraries, these calls are picked up by the VM and handled by the VM.