Migliorare performance per scrivere su un file di testo

[bircastri]

Salve ragazzi.

Ho da sottoporvi un quesito.

Ho una applicazione swing, con una JTable.
La JTable, può avere un numero variabile di righe.

Alla pressione di un tasto, viene richiamato un metodo il quale cicla sulla tabella recuperando gli oggetti della tabella riga per riga.

Aggiorna per ogni riga la corrispondente sul DB, inoltre scrive su un file di testo.

Ora il mio obiettivo è quello di velocizzare la creazione e scrittura di questo file di testo.

Attualmente io faccio così

public void scriviFile(String[] array){
FileOutputStream file = new FileOutputStream("C:/Users/Downloads/file.txt");
	       PrintStream Output = new PrintStream(file);
for(int i=0; i<array.length; i++){
	       Output.println(array[i]);
}
Output.close;
}

in pratica quando aggiorno il db mi creo un array, con tutte le righe che devo scrivere.

Ho ottimizzato leggermente il codice facendo in modo che nel ciclo in cui mi creo l'array, mi scrivo direttamente il file.

Quindi quando l'utente clicca sul pulsante vado in un metodo in cui

ciclando per le righe della tabella, per ogni riga, eseguo una query a db e scrivo una nuova riga sul file di testo.

In questo modo ho risparmiato un ciclo.

Non ci sarebbe una soluzione più performante?? Vi spiego capita molto spesso che la creazione di questo file diventa lunga questo perchè ogni tanto sapete che il sistema operativo fa delle operazioni e quindi questo potrebbe provocare lentezza nell'accesso al disco

grazie

[valia]

guarda per le scritture su file purtroppo non si possono fare miracoli, visto che comunque dipende molto dal sistema operativo e dal carico della macchina.
Puoi velocizzare l'accesso a db...ma mi chiedo, perché questa doppia persistenza? (curiosità la mia)

[bircastri]

perchè questo file di testo viene processato da un registratore di cassa che emette uno scontrino fiscale allora a db devo ovviamente registrate le operazioni, aggiornare il magazzino, sul file di testo invece ci sono i codici per dialogare con il registratore di cassa

[Caiodark]

Se l'obiettivo è aumentare la responsività dell'interfaccia potresti andare a scrivere sul file su un thread separato. Così l'applicazione ritorna subito il controllo.

[bircastri]

cioè tu dici, quando l'utente clicca su start, io chiamo due metodi contemporaneamente uno scrive su file di testo e l'altro invece scrive su db? giusto?

Io ho notato questo, il tempo maggiore viene impiegato quando eseguo l'istruzione FileOutputStream, in pratica quando creo il file.

Allora ho fatto iun questo modo, ogni qualvolta io apro la classe che mi mostra la tabella ecc ecc mi creo il file e lo tengo aperto. In questo modo diciamo che riesco a recuperare un pò di tempo ma sto estando il problema è che usl mio computer qualunque sia il metodo l'applicazione è vewloce come l'accesso al disco ma io uso Win 7 mentre l'applicazione gira su win xp.

[valia]

devi far fare la scrittura del file da uno swing worker, sincronizzando ovviamente in maniera opportuna.
La velocità di una applicazione dipende da tanti fattori, detta così non ha molto senso...
Tener il file sempre aperto non è opportuno: chi lo legge ha accesso quando c'è il lock in scrittura? la scrittura è fatta spesso? devi ritornare all'inizio del file ogni volta e cancellare tutto. (ora lo fai).

[bircastri]

No in pratica funziona così, ogni qual volta il file.txt viene chiuso
"Output.close" il registratore di cassa taglia il file per processarlo. Quindi io ogni bolta ne creo uno nuovo.

Mi potete fare un esempio... (swing worker?)

[valia]

tu hai detto " mi creo il file e lo tengo aperto", quindi significa che non lo chiudi.

swing worker

è la soluzione che fa per te, ma è riduttivo spiegartelo in un post. La documentazione ufficiale è ottima

[LeleFT]

Per cercare di migliorare un po' la situazione ecco il mio consiglio.

Se stai scrivendo dei file di testo, usa un PrintWriter associato ad un BufferedWriter a sua volta associato ad un FileWriter. In questo modo benefici di due "ottimizzazioni": le classi Writer, rispetto alle classi Stream, sono progettate appositamente per il testo; in più, l'utilizzo di un BufferedWriter ti consente di bufferizzare le scritture, diminuendo gli accessi fisici al disco.

Puoi tentare anche di diminuire ulteriormente le scritture usando uno StringBuffer in cui accodare le varie righe... ma è una non-soluzione (un artificio in più) perchè il BufferedWriter dovrebbe essere già sufficientemente performante.

// Uso un Writer anzichè uno Stream perchè è più adatto ai caratteri
FileWriter fw = new FileWriter("C:/Users/Downloads/file.txt");

// Uso un Buffer, così limito gli accessi fisici al disco
BufferedWriter bw = new BufferedWriter( fw );

// Uso un Printer così ho diversi metodi utili (print/println)
PrintWriter pw = new PrintWriter( bw );

Ricordati, comunque, di effettuare un flush() prima di chiudere il file... non uno per ogni scrittura (altrimenti perdi l'agevolazione data dalla bufferizzazione), ma uno solo appena prima di chiudere il file.

Io solitamente uso questa struttura:

FileWriter fw = null;
BufferedWriter bw = null;
PrintWriter pw = null;

try {
   fw = new FileWriter("C:/Users/Downloads/file.txt");
   bw = new BufferedWriter( fw );
   pw = new PrintWriter( bw );

   ...
   pw.println( ... );   // Scrivo una riga sul file
   ...

   // Ho finito... faccio il flush di tutto
   pw.flush();
} catch (Exception e) {
   e.printStackTrace();
} finally {
   if (pw != null) {
      try { pw.close(); } catch (Exception e) { }
   } else {
      if (bw != null) {
         try { bw.close(); } catch (Exception e) { }
      } else {
         if (fw != null) {
            try { fw.close(); } catch (Exception e) { }
         }
      }
   }
}

Ciao.

[bircastri]

Ciao e grazie, proverò con quest'ultima soluzione. Vedo un attimo se riusciamo a risolvere un pò il problema.

ovviamente adesso non avendo la macchina a disposizione non posso fare dei test in condizioni reali di lavoro. Spero di risolvere al più presto il mio problema.

Grazie comunque se ovviamente avete ulteriori consigli io sono sempre ben lieto di ottimizzare il codice.