Understanding How Java Open Files Without a System Cache for Reading and Writing Data

Question Summary

Could you tell me how Java can do the following things that Win32 API does?
"Open files without a system cache to read and write data"

I'm investigating, but I can't find any means at the moment.
Also, I received information that sun.nio.fs.WindowsNativeDispatcher is possible, but I gave up the package below sun because I cannot use it due to business reasons.

ReferencesSite

• Open the file with the flagsAndAttributes argument in CreateFile and FILE_FLAG_NO_BUFFERING
  https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
• System Cache
  https://learn.microsoft.com/ja-jp/windows/win32/fileio/file-caching

Why NO_BUFFERING is required

Thank you for your advice on this question.Add a description of why NO_BUFFERING is required.

For example, let's say that two people, A and B, performed the following tasks for a single file at approximately the same time.
①A looks at the file
②B also refer to the above file
③A updates the above files
④B refers to the above file

When referring to の, there is no particular problem as long as the contents updated by A are reflected.
However, in the unlikely event that the contents of the actual file are referring to an unreflected disk cache, B is concerned that it will end up referring to a file that does not reflect the updated contents of A (reference in the state of = 2).

Therefore, if we can refer to NO_BUFFERING, the above concerns will be resolved.
In addition, there is a possibility that exclusive control may be used to solve the problem, but due to business reasons, it is impossible to add exclusive control.

Research so far

When you open a file using Java's java.io.FileInputStream, it appears that you open it using the system cache.
以下 As a result of following the source as below, it appears to be open with FILE_ATTRIBUTE_NORMAL for CreateFileWflagsAndAttributes.

• FileInputSteram.java File Open, When Loading Files
  https://github.com/AdoptOpenJDK/openjdk-jdk8u/blob/master/jdk/src/share/classes/java/io/FileInputStream.java
  Constructor o open o open 0.

publicFileInputStream(File file)throwsFileNotFoundException{
    String name=(file!=null?file.getPath():null);
    SecurityManager security=System.getSecurityManager();
    if(security!=null){
        security.checkRead(name);
    }
    if(name==null){
        through new NullPointerException();
    }
    if(file.isInvalid()){
        through new FileNotFoundException("Invalid file path");
    }
    fd = new FileDescriptor();
    fd.attach(this);
    path=name;
    open(name);
}
private void open (String name) threads FileNotFoundException {
    open0(name);
}
private native void open0(String name) threads FileNotFoundException;

• FileInputStream.c
  https://github.com/AdoptOpenJDK/openjdk-jdk8u/blob/master/jdk/src/share/native/java/io/FileInputStream.c
  Open0 f fileOpen.

JNIEXPORT void JNICALL Java_java_io_FileInputStream_open0(JNIEnv*env, jobject this, jstring path){
    fileOpen(env, this, path, fis_fd, O_RDONLY); 
}

• io_util_md.c
  https://github.com/AdoptOpenJDK/openjdk-jdk8u/blob/9a751dc19fae78ce58fb0eb176522070c992fb6f/jdk/src/windows/native/java/io/io_util_md.c
  fileOpen w winFileHandleOpen.

void fileOpen(JNIenv*env, job this, jstring path, jfieldID fid, int flags) {
    FD h = winFileHandleOpen(env, path, flags);
    if(h>=0){
        SET_FD(this,h,fid);
    }
}
FD
winFileHandleOpen(JNIEnv*env, jstring path, int flags) {
    const DWORD access=
        (flags&O_WRONLY)?GENERIC_WRITE:
        (flags&O_RDWR)?(GENERIC_READ|GENERIC_WRITE):
        GENERIC_READ;
    const DWORD sharing=
        FILE_SHARE_READ | FILE_SHARE_WRITE;
    const DWORD disposition=
        /* Note: O_TRUNCoverrides 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;

    WCHAR* pathbuf = pathToNTPath(env, path, JNI_TRUE);
    if(pathbuf==NULL){
        /* Exception already pending*/
        return-1;
    }
    h = CreateFileW(
        pathbuf, /* Wide char pathname */
        access, /* Read and /or write permission*/
        sharing, /* File sharing flags */
        NULL, /* Security attributes*/
        disposition, /* creation disposition*/
        flagsAndAttributes, /* flags and attributes*/
        NULL);
    free(pathbuf);

    if(h==INVALID_HANDLE_VALUE){
        throughFileNotFoundException(env, path);
        return-1;
    }
    return(jlong)h;
}

Thank you for your cooperation.