Come posso bloccare un file usando java (se possibile)

Ho un processo Java che apre un file utilizzando un FileReader. Come posso impedire a un altro processo (Java) di aprire questo file o almeno notificare al secondo processo che il file è già aperto? Questo fa sì che il secondo processo ottenga automaticamente un'eccezione se il file è aperto (il che risolve il mio problema) o devo aprirlo esplicitamente nel primo processo con una sorta di flag o argomento?

Chiarire:

Ho un'app Java che elenca una cartella e apre ogni file nell'elenco per elaborarlo. Elabora ogni file dopo l'altro. L'elaborazione di ogni file consiste nel leggerlo e fare alcuni calcoli in base al contenuto e richiede circa 2 minuti. Ho anche un'altra app Java che fa la stessa cosa ma invece scrive sul file. Quello che voglio è essere in grado di eseguire queste app allo stesso tempo, quindi lo scenario va così. ReadApp elenca la cartella e trova i file A, B, C. Apre il file A e avvia la lettura. WriteApp elenca la cartella e trova i file A, B, C.Apre il file A, vede che è aperto (per un'eccezione o in qualsiasi modo) e va al file B. ReadApp termina il file A e continua su B.Vede che è aperto e continua a C. È fondamentale che WriteApp non lo faccia t scrivere mentre ReadApp sta leggendo lo stesso file o viceversa. Sono processi diversi.

FileChannel.lock è probabilmente quello che vuoi.

try (
    FileInputStream in = new FileInputStream(file);
    java.nio.channels.FileLock lock = in.getChannel().lock();
    Reader reader = new InputStreamReader(in, charset)
) {
    ...
}

(Disclaimer: codice non compilato e certamente non testato.)

Nota la sezione intitolata "dipendenze dalla piattaforma" nel documento API per FileLock .

Non usare le classi nel java.iopacchetto, usa invece il java.niopacchetto. Quest'ultimo ha una FileLockclasse. Puoi applicare un blocco a un file FileChannel.

 try {
        // Get a file channel for the file
        File file = new File("filename");
        FileChannel channel = new RandomAccessFile(file, "rw").getChannel();

        // Use the file channel to create a lock on the file.
        // This method blocks until it can retrieve the lock.
        FileLock lock = channel.lock();

        /*
           use channel.lock OR channel.tryLock();
        */

        // Try acquiring the lock without blocking. This method returns
        // null or throws an exception if the file is already locked.
        try {
            lock = channel.tryLock();
        } catch (OverlappingFileLockException e) {
            // File is already locked in this thread or virtual machine
        }

        // Release the lock - if it is not null!
        if( lock != null ) {
            lock.release();
        }

        // Close the file
        channel.close();
    } catch (Exception e) {
    }

Se puoi usare Java NIO ( JDK 1.4 o superiore ), penso che tu stia cercandojava.nio.channels.FileChannel.lock()

FileChannel.lock ()

utilizzare java.nio.channels.FileLock insieme a java.nio.channels.FileChannel

Questo potrebbe non essere quello che stai cercando, ma nell'interesse di affrontare un problema da un'altra angolazione ...

Questi due processi Java che potrebbero voler accedere allo stesso file nella stessa applicazione? Forse puoi semplicemente filtrare tutti gli accessi al file attraverso un unico metodo sincronizzato (o, ancora meglio, usando JSR-166 )? In questo modo, puoi controllare l'accesso al file e forse anche accodare le richieste di accesso.

Usa un RandomAccessFile, ottieni il suo canale, quindi chiama lock (). Il canale fornito dai flussi di input o output non dispone di privilegi sufficienti per bloccarsi correttamente. Assicurati di chiamare unlock () nel blocco finalmente (la chiusura del file non rilascia necessariamente il blocco).

Di seguito è riportato un frammento di codice di esempio per bloccare un file finché il suo processo non viene eseguito da JVM.

 public static void main(String[] args) throws InterruptedException {
    File file = new File(FILE_FULL_PATH_NAME);
    RandomAccessFile in = null;
    try {
        in = new RandomAccessFile(file, "rw");
        FileLock lock = in.getChannel().lock();
        try {

            while (in.read() != -1) {
                System.out.println(in.readLine());
            }
        } finally {
            lock.release();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}