Java NIO - FileLock

Come sappiamo, Java NIO supporta la concorrenza e il multi threading che gli consente di gestire più thread che operano su più file contemporaneamente, ma in alcuni casi richiediamo che il nostro file non venga condiviso da nessuno dei thread e non sia accessibile.

Per tale requisito NIO fornisce nuovamente un'API nota come FileLock che viene utilizzata per fornire il blocco su tutto il file o su una parte del file, in modo che quel file o la sua parte non vengano condivisi o accessibili.

per fornire o applicare tale blocco dobbiamo utilizzare FileChannel o AsynchronousFileChannel, che fornisce due metodi lock() e tryLock()a tale scopo La serratura fornita può essere di due tipi:

  • Exclusive Lock - Un blocco esclusivo impedisce ad altri programmi di acquisire un blocco sovrapposto di entrambi i tipi.

  • Shared Lock - Un blocco condiviso impedisce ad altri programmi in esecuzione simultanea di acquisire un blocco esclusivo sovrapposto, ma consente loro di acquisire blocchi condivisi sovrapposti.

Metodi utilizzati per ottenere il blocco su file -

  • lock() - Questo metodo di FileChannel o AsynchronousFileChannel acquisisce un blocco esclusivo su un file associato al canale specificato. Il tipo di ritorno di questo metodo è FileLock che viene ulteriormente utilizzato per monitorare il blocco ottenuto.

  • lock(long position, long size, boolean shared) - Questo metodo è ancora il metodo sovraccarico del metodo di blocco e viene utilizzato per bloccare una parte particolare di un file.

  • tryLock() - Questo metodo restituisce un FileLock o un null se non è stato possibile acquisire il blocco e tenta di acquisire un blocco esplicitamente esclusivo sul file di questo canale.

  • tryLock(long position, long size, boolean shared) - Questo metodo tenta di acquisire un blocco su una determinata regione del file di questo canale che può essere di tipo esclusivo o condiviso.

Metodi della classe FileLock

  • acquiredBy() - Questo metodo restituisce il canale su cui è stato acquisito il blocco del file.

  • position() - Questo metodo restituisce la posizione all'interno del file del primo byte della regione bloccata. Una regione bloccata non deve essere contenuta o addirittura sovrapposta al file sottostante effettivo, quindi il valore restituito da questo metodo potrebbe superare la dimensione corrente del file.

  • size() - Questo metodo restituisce la dimensione della regione bloccata in byte. Una regione bloccata non deve essere contenuta all'interno o addirittura sovrapposta al file sottostante effettivo, quindi il valore restituito da questo metodo potrebbe superare la dimensione corrente del file.

  • isShared() - Questo metodo viene utilizzato per determinare se il blocco è condiviso o meno.

  • overlaps(long position,long size) - Questo metodo indica se questo blocco si sovrappone o meno all'intervallo di blocco specificato.

  • isValid() - Questo metodo indica se il blocco ottenuto è valido o meno. Un oggetto blocco rimane valido fino a quando non viene rilasciato o il canale file associato viene chiuso, a seconda di cosa si verifica per primo.

  • release()- Rilascia il blocco ottenuto. Se l'oggetto blocco è valido, l'invocazione di questo metodo rilascia il blocco e rende l'oggetto non valido. Se questo oggetto di blocco non è valido, il richiamo di questo metodo non ha alcun effetto.

  • close()- Questo metodo richiama il metodo release (). È stato aggiunto alla classe in modo che potesse essere utilizzato insieme al costrutto del blocco di gestione automatica delle risorse.

Esempio per dimostrare il blocco dei file.

L'esempio seguente crea un blocco su un file e scrivi il contenuto su di esso

package com.java.nio;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
public class FileLockExample {
   public static void main(String[] args) throws IOException {
      String input = "Demo text to be written in locked mode.";  
      System.out.println("Input string to the test file is: " + input);  
      ByteBuffer buf = ByteBuffer.wrap(input.getBytes());  
      String fp = "D:file.txt";  
      Path pt = Paths.get(fp);  
      FileChannel channel = FileChannel.open(pt, StandardOpenOption.WRITE,StandardOpenOption.APPEND);  
      channel.position(channel.size() - 1); // position of a cursor at the end of file       
      FileLock lock = channel.lock();   
      System.out.println("The Lock is shared: " + lock.isShared());  
      channel.write(buf);  
      channel.close(); // Releases the Lock  
      System.out.println("Content Writing is complete. Therefore close the channel and release the lock.");  
      PrintFileCreated.print(fp);  
   }  
}
package com.java.nio;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class PrintFileCreated {
   public static void print(String path) throws IOException {  
      FileReader filereader = new FileReader(path);  
      BufferedReader bufferedreader = new BufferedReader(filereader);  
      String tr = bufferedreader.readLine();    
      System.out.println("The Content of testout.txt file is: ");  
      while (tr != null) {      
         System.out.println("    " + tr);  
         tr = bufferedreader.readLine();  
      }  
   filereader.close();  
   bufferedreader.close();  
   }  
}

Produzione

Input string to the test file is: Demo text to be written in locked mode.
The Lock is shared: false
Content Writing is complete. Therefore close the channel and release the lock.
The Content of testout.txt file is: 
To be or not to be?Demo text to be written in locked mode.