Garbage Collector in Java

Linea di comportamento del garbage collector (recuperatore di memoria)

Il programmatore Java non ha bisogno di monitorare l'allocazione della memoria perché il garbage collector gestisce la memoria automaticamente. Il Garbage Collector è gestito dalla Java Virtual Machine (JVM). Il Garbage Collector è un processo a bassa priorità che viene eseguito periodicamente e libera la memoria utilizzata dagli oggetti che non sono più necessari. Diverse JVM hanno diversi algoritmi di garbage collection. Esistono diversi algoritmi utilizzati, ad esempio: algoritmo di conteggio dei riferimenti o algoritmi di markup e scraping.

Esecuzione del Garbage Collector in Java

La JVM in genere esegue il Garbage Collector quando la memoria libera è insufficiente. Ma il funzionamento del Garbage Collector non garantisce che ci sia sempre abbastanza memoria libera. Se la memoria non è sufficiente anche dopo il ripristino, la JVM genera un'eccezione OutOfMemoryError. Tieni presente che la JVM deve eseguire il Garbage Collector almeno una volta prima di generare un'eccezione. È possibile richiedere l'esecuzione del Garbage Collector in Java, ma non è possibile forzare questa azione.

Richiesta di eseguire il Garbage Collector

Per effettuare una richiesta è possibile chiamare una delle seguenti modalità:

System.gc()
Runtime.getRuntime().gc()

Idoneità all'esecuzione del garbage collector

Un oggetto deve essere smaltito quando non è più disponibile per il flusso vivente. Un oggetto può essere oggetto di smaltimento in diversi casi:

• Se una variabile di tipo riferimento che fa riferimento a un oggetto è impostata su "0", l'oggetto deve essere eliminato se non esistono altri riferimenti ad esso.
• Se una variabile di tipo riferimento che fa riferimento a un oggetto viene creata per fare riferimento a un altro oggetto, l'oggetto deve essere eliminato se non sono presenti altri riferimenti ad esso.
• Gli oggetti creati localmente in un metodo vengono scartati quando il metodo termina, a meno che non vengano esportati da quel metodo (ovvero restituiti o generati come eccezione).
• Gli oggetti che fanno riferimento tra loro possono essere soggetti a smaltimento se nessuno di essi è disponibile per il thread attivo.

Diamo un'occhiata ad un esempio:

public class TestGC
  {
    public static void main(String [] args)
    {
      Object o1 = new Integer(3);               // Line 1
      Object o2 = new String("Tutorial");       // Line 2
      o1 = o2;                                  // Line 3
      o2 = null;                                // Line 4
      // Rest of the code here
    }
  }

In questo esempio Integer, l'oggetto (intero) originariamente a cui fa riferimento o1 può essere eliminato dopo la riga 3 perché o1 ora si riferisce all'oggetto String(stringa). Anche se o2 viene creato per fare riferimento a null, l'oggetto String(stringa) non è riciclabile poiché o1 si riferisce ad esso.

Finalizzazione

La tecnologia Java consente di utilizzare un metodo finalize()(finalizzazione) per eseguire la pulizia necessaria prima che il Garbage Collector recuperi un oggetto dalla memoria. Questo metodo viene chiamato su un oggetto dal Garbage Collector quando il Garbage Collector determina che non sono più presenti riferimenti all'oggetto. Questo è descritto nella classe Object, il che significa che è ereditato da tutte le classi. La sottoclasse sovrascrive il metodo finalize()per liberarsi dalle risorse di sistema o per un'altra pulizia:

protected void finalize() throws Throwable

Se il metodo genera un'eccezione non registrata finalize(), l'eccezione viene ignorata e la finalizzazione dell'oggetto si interrompe. Il metodo finalize()verrà richiamato solo una volta durante la vita dell'oggetto. È possibile utilizzare un metodo finalize()su qualsiasi oggetto per proteggerlo dallo smaltimento. Ma in questo caso il Garbage Collector non è più attivato finalize()per questo oggetto. Il metodo finalize()verrà sempre richiamato una volta prima che l'oggetto venga sottoposto a Garbage Collection. È tuttavia possibile che la modalità finalize()non venga attivata per un determinato oggetto per tutta la durata della sua esistenza, poiché potrebbe non essere soggetto a smaltimento.

Riepilogo

In questa sezione abbiamo esaminato il processo di garbage collection, che è una tecnica di gestione della memoria nel linguaggio Java. La raccolta dei rifiuti non può essere forzata. Abbiamo appreso i diversi modi per rendere gli oggetti idonei al riciclo e abbiamo appreso che il metodo finalize()viene richiamato prima che l'oggetto venga recuperato dal garbage collector.

Esercizio

Domanda: Quanti oggetti saranno oggetto di smaltimento dopo la linea 7?

public class TutorialGC
  {
    public static void main(String [] args)
    {
      Object a = new Integer(100);  // Line1
      Object b = new Long(100);     // Line2
      Object c = new String("100"); // Line3
      a = null;                     // Line4
      a = c;                        // Line5
      c = b;                        // Line6
      b = a;                        // Line7
      // Rest of the code here
    }
  }

Opzioni di risposta: A. 0 B. 1 C. 2 D. 3 E. Il codice non è compilabile Opzione corretta: B Spiegazione: Dei tre oggetti creati nelle righe 1, 2 e 3, solo l'oggetto Integerdeve essere smaltito alla fine fine della riga 7. Riferimenti variabili, a, che originariamente faceva riferimento all'oggetto Integer, fa riferimento all'oggetto Stringsulla riga 5. Pertanto, Integerl'oggetto deve essere eliminato dopo la riga 5, poiché non ci sono variabili che fanno riferimento ad esso. Le variabili be csi riferiscono agli oggetti Stringe Longagli oggetti delle righe 6 e 7, quindi non sono riciclabili.