Newsgroup: it.comp.java
Titolo: Java e BZip2

Ciao a tutti,
sto cercando di usare le librerie JAXLIB, in particolare il package
jaxlib.arc.bz2lib, per una mia applicazione che richiede la
decompressione di file in formato BZIP2. 
L'applicazione di per se effettua un ciclo: ricezione del file,
decompressione, invio dei risultati. Premetto che i file da
decomprimere vengono ricevuti ad intervalli casuali... non importa
pero il tempo di risposta, basta che i file vengano scompattati
correttamente.... pero riscontro due problemi:
1) il consumo di memoria è eccessivo: ad ogni file ricevuto la memoria
occupata dalla applicazione aumenta.... fino a raggiungere gli 80 mega
di occupazione (il limite massimo impostato) e al termina di ogni
decompressione la memoria NON viene liberata...
2) il consumo di cpu.... è notevole ma visto che richiedo la
decompressione all'interno di un thread a bassa priorita mi chiedo del
perche la decompressione rallenti di molto il sistema... (blocco
temporaneo della gui , mouse che scatta ecc) . Da quanto ho visto nel
codice le librerire nn usano thread interni... perche la
decompressione avviene invece come se il thread avesse priorita
normale? 
Il file da decomprimere viene passato direttamente alla libreria
BZ2... pero il risultato viene memorizzato in uno RAM file usando la
classe ByteArrayOutputStream.... per poter essere letto, decompresso,
tramite uno stream ByteArrayInputStream....che poi viene ovviamente
chiuso. 
Puo essere questo uno dei fattori che aumentano il consumo di memoria?
ma è strano... teoricamente il file una volta decompresso ed
elabrorato viene eliminato dalla memoria.... perche invece la memoria
nn viene liberata? 
Vi posto un po di codice.. la funzione decodifica che si occupa della
decompressione del file ricevuto. 
Il risultato viene memorizzato in buffer una variabile privata della
classe.... e viene di nuovo ottenuta richiedendo il file byte buffer
array. 
   public synchronized char[] decodifica(String file) {
      FileInputStream in = null;
      ByteArrayOutputStream out = null;
      BZip2InputStream stream = null;
      boolean completato = true;
      try {
         // il file viene caricato dal disco
         in  = new FileInputStream(file);
         // viene creato il file
         out = new ByteArrayOutputStream();
      }
      catch (FileNotFoundException e) {
         return false;
      }
      try {
         // legge lo stream compresso e lo copia
         // nello stream del ram file.
         stream = new BZip2InputStream(in);
         int ch = stream.read();
         while (ch!=-1) {
            out.write(ch);
            ch = stream.read();
         }
      }
      catch (Exception e) {
         completato = false;
      }
      try {
         // non è detto che lo stream compresso sia stato
         // creato correttamente...
         if (stream!=null) stream.close();
         // chiude i file di lettura/scrittura
         in.close();
         out.close();
      }
      catch (IOException e) {
         completato = false;
      }
      // assegna il buffer
      buffer = out.toByteArray();
      // cancella gli stream di input e di output
      in     = null;
      out    = null;
      stream = null;
      // ritorna il risultato
      return completato? buffer:null;
   }
Qualcuno sa darmi consigli/suggerimenti? ve ne sarei molto grato....
DamageInc



Nessuno ha qualche suggerimento? Solo una domanda: la decompressione
occupa cpu... quindi il gc non viene fatto partire visto che i file
arrivano uno di seguito all'altro... è possibile che questo nn
permetta al gc di compiere il proprio lavoro? e se modificassi il
modulo per la decompressione dei file bz2 in modo che occupi blocchi
di memoria una sola volta (in pratica statico), potrebbe risolvere il
mio problema? mi interessa che i file vengano decompressi in serie....