JAVA：- 多个 Java 应用程序之间的文件共享和锁定在 Linux 中不起作用

Question

I have two separate Java processes. Say ABC and DEF. DEF is the child of ABC ( That is, DEF is spawned by ABC. Both ABC and DEF are spawned using two jar files ABc.jar and DEF.jar respectively). My requirement is to keep a file common to both ABC and DEF. This file is created by ABC and will be locked. DEF checks if the file is unlocked. If unlocked, the process DEF exits. This is to account for the issue of Orphan process wherein the child process is not killed when a parent process crashes.

So, In this case, the created file by ABC will remain locked until ABC exits. DEF is already checking if the lock of the file is released. Since the condition for the lock to be released being ABC terminating, DEF terminates as soon as ABC terminates.

So, I have created a FileLock.java class in the ABC process:-

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileLock;

public class FileLock {

    public FileLockExample() throws FileNotFoundException {
        FileOutputStream fileOutStream;
        try {
            fileOutStream= new FileOutputStream("Temp.txt");
            FileLock fileLock ;
            try {
                fileLock = fileOutStream.getChannel().tryLock();
                if (fileLock != null) {
                    System.out.println("Locked File");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();
        }

    }
}

So, a file Temp.txt is created and is locked.

Now I have added a function in DEF where I check if the file is locked.

public static void isFileUnlocked() {
        Integer count = 1000;
        boolean isFirstTry = false;
        while (count > 0) {
            try {
                if (!isFirstTry) {
                    FileOutputStream fos = new FileOutputStream("Temp.txt");
                    FileLock fileLock = fos.getChannel().tryLock();
                    isFirstTry = true;
                }
                FileInputStream fis = new FileInputStream("Temp.txt");
                fis.read();
                System.exit(0);
            } catch (IOException x) {

            }
          Thread.sleep(1000);
          count--;
        }
    }

The function isFileUnlocked() in process DEF checks if the file lock is released for every one second. If the lock is released, It means that ABC has been terminated due to some reasons. So, DEF exits as soon as the file lock is released.

I verified this in Windows and it seems to be working. Hwever, In Linux, the process DEF exists as soon as the function isFileUnlocked() is called. Thus when DEF tries to read the file, It is able to do so. (Which might mean that the file is unlocked).

Any thoughts on this?

Answer 1

Assuming the [locked] file is not closed when method checkIfFileIsUnlocked() is called and also assuming that you are invoking method checkIfFileIsUnlocked() with the correct parameter, in order to test whether the file is locked, you need to read from the file. Merely opening the file will not throw an exception.

This is a very badly written example but it is merely intended to demonstrate how to implement your check.

try {
    FileOutputStream fos = new FileOutputStream("lockfile.txt");
    FileLock fileLock = fos.getChannel().tryLock();

    FileInputStream fis = new FileInputStream("lockfile.txt");
    fis.read();
}
catch (IOException x) {
    x.printStackTrace();
}

When the above code runs, the following line throws an exception.

fis.read()

The exception is:

java.io.IOException: The process cannot access the file because another process has locked a portion of the file