Apri e chiudi lo stesso file più volte rispetto all'apertura del file per molto tempo

Question

Sto scrivendo a un File ogni volta che si modifica il contenuto nel campo JTextArea. Ho deciso di aprire e chiudere il contenuto del file ogni volta secondo l'evento di modifica.

Qualcosa di simile,

public void addToLogFile(String changeContent) { 
    try { 
     PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(currentLogFile,true))); 
     pw.print(changeContent); 
     pw.close(); 
    } catch (FileNotFoundException ex) { 
     Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex); 
    } catch (IOException ex) { 
     Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex); 
    } 
} 

Invece di aprire e chiudere il file ogni volta, ho pensato che potrebbe essere potevamo aprirlo nella fase iniziale e scaricare contenuti in qualsiasi momento. Alla fine chiudilo alla fine.

Alla fase iniziale del programma:

PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(currentLogFile,true))); 

Poi da qualche parte nel codice, ovunque sia necessario,

pw.print(changeContent); // Most frequent usage 

Alla fase finale del programma:

pw.close(); 

Quale uno sarà più efficiente ? In quali condizioni, devo sceglierne una?

Answer 1

Più efficace sarebbe sicuramente l'apertura del file una volta. Aprire il file ogni volta è piuttosto costoso.

Un caso può essere utile quando le nuove voci del file si verificano una volta ogni tanto, quindi il sistema operativo non deve contenere il gestore di file aperto.

Un altro caso in cui prenderei in considerazione l'apertura e la chiusura ogni volta è quando le scritture si verificano non così spesso e si desidera consentire agli altri processi di scrivere nel file. O forse quando vuoi assicurarti che ogni entrata sia visibile subito dopo averla scritta, ma allora dovresti semplicemente scaricare il buffer.

Answer 2

Non tenere aperto il file potrebbe essere un'opzione se si dispone di molti di questi campi di testo, in cui ognuno di essi è protetto da un file diverso. Quindi, se il numero di campi di testo si avvicina al limite del file aperto, è probabile che il tuo programma non possa aprire altri file, socket o altro, quando ciascuno dei campi occuperebbe un descrittore di file.

Ma, naturalmente, questa è una considerazione puramente teorica. Il limite dei file aperti è in genere intorno al 2000 e difficilmente riesco ad immaginare un'applicazione con 2000 campi di input di testo.

Detto questo, le prime versioni dell'utilità di ricerca di unix si occupavano di chiudere e successivamente riaprire le directory attraversate, per evitare problemi con i decodificatori di file che si esaurivano. Ma questo era nei primi giorni in cui il limite era di circa 20 anni.