Visualizzazione dei risultati da 1 a 7 su 7
  1. #1

    [Java] Utilizzo delle risorse

    Salve,
    scusate la lunghezza del thread ma ho un quesito ,per me spinoso, da porvi.

    Ho creato un programma che lavoro con 18 oggetti diversi e vorrei trovare la soluzione ideale per ottimizzarlo sia in termini di velocità che di uso delle risorse.

    Attualmente uso il seguente schema:
    • Ognuno dei 18 oggetti è più o meno composto in questo modo :
      codice:
      //...diversi import...
      public class Classe  {
      
          public JPanel panCENTRO = new JPanel();
          //...tante altre variabili...
                    
          public Classe() {}
      
          public void azioni() {}			
      	//...tanti altri metodi...
          
      }
    • La classe che gestisce gli oggetti lavora più o meno in questo modo :
      codice:
      //...diversi import...
      public class Principale  {
      
          public JPanel panCENTRO = new JPanel();
      	public Classe1 uno=new Classe1();
      	public Classe2 due=new Classe2();
      	public Classe3 tre=new Classe3();
      	...
      	public Classe18 diciotto=new Classe18();
          //...tante altre variabili...
                    
          public Principale() {}
      
          public void uno() {
      		uno.lavora();
      	}	
      
      
      	public void due() {
      		due.lavora();
      	}		
      	//...tanti altri metodi...
          
      }


    In pratica con questo schema carico tutto all'avvio del programma ma l'uso delle risorse è eccessivo.

    Ho pensato a due alternative :
    • A) Modificare la classe principale in questo modo :
      codice:
      //...diversi import...
      public class Principale  {
      
          public JPanel panCENTRO = new JPanel();              
          public Principale() {}
      
          public void uno() {	
      		Classe1 uno=new Classe1();
      		uno.lavora();
      		uno=null;
      		r.gc(); //chiamo il garbage collector
      	}	
      
      
      	public void due() {
      		Classe2 due=new Classe2();
      		due.lavora();
      		due=null;
      		r.gc(); //chiamo il garbage collector
      	}		
      	//...tanti altri metodi...
          
      }
      In questo modo non carico all'avvio i 18 oggetti ma l'istanzio solo quando servono, ora vi chiedo :
    • A.1)risparmio davvero la memoria e l'utilizzo delle risorse?
    • A.2)Alla fine del metodo la classe istanziata viene deferenziata quindi con garbage collector dovrei riuscire a liberare le risorse occupate, giusto?
    • B)Vorrei utilizzare i thread, tecnica che non ho mai usato prima ma che a grandi linee vorrei utilizzare in questi modo:
    • 1)Associare ad ogni thread un oggetto diverso
    • 2)Farli partire in contemporanea e lavorare con i metodi di Thread come start,stop ecc
      Con questa tecnica riuscirei ad ottimizzare l'uso delle risorse?


    Avete altre alternative da suggerirmi?

    Grazie per le eventuali risposte!

    Saluti
    Junky.Funki
    E' tutta colpa di Berlusconi !
    Help [Ciclico] Fisco, domande varie

    Avatar

  2. #2
    certamente allocare gli oggetti solo quando servono è una buona strategia. Non solo: nel tuo esempio iniziale il loro ciclo di vita è quello dell'applicazione. Nel secondo caso no.
    Però attenzione: nel primo caso allochi al massimo 1 oggetto per classe; nel secondo caso dipende: deferenziando gli oggetti creati ogni volta che richiami, per esempio, uno() ricrei un nuovo oggetto.

    LASCIA STARE r.gc()!

    Non migliora assolutamente nulla. Il motivo è che tu "suggerisci" di eseguire il garbage collector. Ma la JVM è ottimizzata abbastanza per capire da sé quando farlo partire.

    Per i thread: a parte imparare come si usano, essi non servono per ottimizzare le risorse. Ma per eseguire in maniera concorrente più parti di programma. Sai tu se questo è quanto vuoi fare.
    Ivan Venuti
    Vuoi scaricare alcuni articoli sulla programmazione, pubblicati su riviste di informatica? Visita http://ivenuti.altervista.org/articoli.htm. Se vuoi imparare JavaScript leggi il mio libro: http://www.fag.it/scheda.aspx?ID=21754 !

  3. #3
    Utente di HTML.it
    Registrato dal
    Feb 2009
    Messaggi
    502
    In Java non devi fare come con la famiglia dei linguaggi C: non devi essere tu che se allochi una variabile, allora devi farti carico della sua distruzione, altrimenti resta in memoria.

    A tutto ci pensa il Garbage Collector: quando la JVM vede un oggetto che non è più referenziato, perché è uscito dal suo scope o per ogni altro motivo, lo "segna" cancellabile, e alla prossima passata del gc lo elimina.
    Tu, richiamando il gc, altro non fai che dirgli: c'è qualcosa di eliminabile? Eliminalo subito. Ma non puoi sapere se c'è qualcosa di eliminabile. E non è detto che richiamando il gc a mano le prestazioni aumentino, perché fai fare del lavoro alla JVM che lei non reputava necessario, distogliendola da altri compiti.

    (Ovviamente quanto sopra è quello che io ho capito del GC, che non è detto sia giusto )
    al volante son nervoso

  4. #4
    Originariamente inviato da ivenuti
    Però attenzione: nel primo caso allochi al massimo 1 oggetto per classe; nel secondo caso dipende: deferenziando gli oggetti creati ogni volta che richiami, per esempio, uno() ricrei un nuovo oggetto.
    Scusa ma non ho chiaro questo tuo passaggio.
    Ogni volta che chiamo il metodo uno() creo un nuovo oggetto di tipo uno.
    Alla fine del metodo deferenzio l'oggetto uno di conseguenza dovrei ,almeno in teoria, liberare le risorse allocate dall'oggeto uno.
    Quindi a cosa devo fare attenzione?

    Inoltre tra questi esempi qual'è secondo te il migliore per occupare meno risorse
    • Metodo A
      codice:
          public void uno() {	
      		Classe1 uno=new Classe1();
      		uno.lavora();
      		uno=null;
      	}
    • Metodo B
      codice:
          Classe1 uno=null;
          public void uno() {	
      		uno=new Classe1();
      		uno.lavora();
      		uno=null;
      	}




    Originariamente inviato da ivenuti
    LASCIA STARE r.gc()!
    Non migliora assolutamente nulla. Il motivo è che tu "suggerisci" di eseguire il garbage collector. Ma la JVM è ottimizzata abbastanza per capire da sé quando farlo partire.
    Originariamente inviato da Rubox
    In Java non devi fare come con la famiglia dei linguaggi C: non devi essere tu che se allochi una variabile, allora devi farti carico della sua distruzione, altrimenti resta in memoria.
    A tutto ci pensa il Garbage Collector: quando la JVM vede un oggetto che non è più referenziato, perché è uscito dal suo scope o per ogni altro motivo, lo "segna" cancellabile, e alla prossima passata del gc lo elimina.
    Tu, richiamando il gc, altro non fai che dirgli: c'è qualcosa di eliminabile? Eliminalo subito. Ma non puoi sapere se c'è qualcosa di eliminabile. E non è detto che richiamando il gc a mano le prestazioni aumentino, perché fai fare del lavoro alla JVM che lei non reputava necessario, distogliendola da altri compiti.
    (Ovviamente quanto sopra è quello che io ho capito del GC, che non è detto sia giusto )
    Ok, ma ho come l'impressione che la JVM ci "pensi" troppo prima di avviare il Garbage Collector.
    Per questo motivo volevo forzare il GC da codice ma se voi dite che non vale la pena potete indicarmi un alternativa al GC per forzare il rilascio delle risorse non più utilizzate?
    E' tutta colpa di Berlusconi !
    Help [Ciclico] Fisco, domande varie

    Avatar

  5. #5
    Utente di HTML.it
    Registrato dal
    Feb 2009
    Messaggi
    502
    Ma a parte che no ho capito.
    Leggi 18 oggetti? E hai problemi di prestazioni / risorse / velocità?

    Con un programma leggevo da porta seriale e costruivo un oggetto con valore, data/tempo di acquisizione, media al momento, media tra lui e i suoi due vicini (una sorta di derivata), verifica di minimo locale, punto di flesso (non matematico, ma mi bastava).
    E i dati in entrata avevano una velocità di 33ms: teoricamente 30 al secondo, praticamente 11, 12 al secondo. L'unico limite che mi si presentava era la quantità di memoria, perché fino a 8, 9 mila campioni non avevo problemi di risorse/velocità.
    Eseguendo anche un grafico dei valori in real-time (double buffering permettendo per evitare il flickering).

    Se con soli 18 oggetti hai problemi di risorse... forse è per come sono organizzati. Non credo per il gc.
    al volante son nervoso

  6. #6
    Originariamente inviato da JunkyFunki
    Ok, ma ho come l'impressione che la JVM ci "pensi" troppo prima di avviare il Garbage Collector.
    Per questo motivo volevo forzare il GC da codice ma se voi dite che non vale la pena potete indicarmi un alternativa al GC per forzare il rilascio delle risorse non più utilizzate?
    L'impressione tua è dovuta al fatto che la JVM dopo che ha passato il GC non rilascia subito memoria al sistema operativo se non ce n'è bisogno, perchè è un operazione costosa e la fa solo quando ne ha tanta messa da parte e la può liberare in un colpo solo oppure quando la RAM libera inizia a scarseggiare, è una grossa ottimizzazione perchè
    1 - quando la memoria ti riservirà, se possibile non c'è bisogno di chiederla al sistema operativo (molto più veloce)
    2 - liberare una manciata di byte migliaia di volte al secondo quando hai 1 GB di ram inutilizzata è un grosso spreco

    Se vuoi sapere quanta memoria sta effettivamente utilizzando il tuo programma il taskmanager è inutile devi usare un profiler per la JVM come jvisualvm (incluso nella JDK).

    codice:
        public void uno() {	
    		Classe1 uno=new Classe1();
    		uno.lavora();
    		uno=null;
    	}
    quell' uno=null alla fine è inutile, l'oggetto "new Classe1()" lo dichiari dentro il metodo, finito quel metodo diventa irrangiungibile e la GC lo elimina a prescindere che "uno" sia null o meno.

    E cmq come ti hanno già detto se il tuo programma è piccolo come penso e ti preoccupi di centellinare memoria e cpu sei fuori strada pensa a scrivere buon codice ordinato e con meno bug possibile, se effettivamente ti va lento hai un bug da qualche parte.

  7. #7
    Originariamente inviato da Rubox
    Ma a parte che no ho capito.
    Leggi 18 oggetti? E hai problemi di prestazioni / risorse / velocità?

    ....

    Se con soli 18 oggetti hai problemi di risorse... forse è per come sono organizzati. Non credo per il gc.
    Originariamente inviato da GoodbyeSoberDay
    E cmq come ti hanno già detto se il tuo programma è piccolo come penso e ti preoccupi di centellinare memoria e cpu sei fuori strada pensa a scrivere buon codice ordinato e con meno bug possibile, se effettivamente ti va lento hai un bug da qualche parte.
    Mi sono limitato a 18 solo per facilitare l'esempio ma tenete conto che ognuno di quei 18 oggetti può aprire altri centinaia di oggetti (fra jtextfield,jlabel, actionlistener,keylistener,focuslistener ecc ecc)
    Il .jar del progetto è di circa 15Mb e sicuramente ci saranno diversi bug da corregere ma vorrei capire qual'è la tecnica migliore per ottimizzare l'uso della memoria e delle risorse aumentandone la velocità d'esecuzione
    E' tutta colpa di Berlusconi !
    Help [Ciclico] Fisco, domande varie

    Avatar

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.