Java - Garbage Collection

Ciao a tutti, futuri maghi Java! Oggi ci imbarqueremo in un viaggio avventuroso nel mondo della Raccolta dei Rifiuti di Java. Non preoccupatevi se siete nuovi nella programmazione – sarò il vostra guida amichevole e esploreremo questo argomento passo per passo. Allora, afferrate la vostra scopa virtuale e puliamo un po' di memoria!

Cos'è la Raccolta dei Rifiuti di Java?

Immagina di essere ad un party che mai finisce (sembrerebbe divertente, vero?). Mentre le persone si godono, lasciano bicchieri e piatti vuoti ovunque. In un party normale, dovresti pulire manualmente. Ma cosa succederebbe se ci fosse un sistema magico di pulizia che rimuove i rifiuti automaticamente senza che te ne accorgi? Questo è sostanzialmente quello che la Raccolta dei Rifiuti di Java fa per i tuoi programmi!

In termini di programmazione, la Raccolta dei Rifiuti (GC) è un sistema automatico di gestione della memoria. Identifica gli oggetti in un programma Java che non sono più necessari e li rimuove per liberare memoria. Questo processo avviene in background, permettendo agli sviluppatori di concentrarsi sulla scrittura del codice piuttosto che gestire la memoria manualmente.

Guardiamo un esempio semplice:

public class EsempioRaccoltaRifiuti {
public static void main(String[] args) {
// Creo un nuovo oggetto
String nome = new String("John Doe");

// La variabile 'nome' ora punta a null
nome = null;

// A questo punto, l'oggetto String originale "John Doe"
// è eleggibile per la raccolta dei rifiuti

// Suggere la esecuzione della raccolta dei rifiuti (non garantita)
System.gc();
}
}

In questo esempio, creiamo un oggetto String "John Doe" e lo assegnamo alla variabile 'nome'. Quando impostiamo 'nome' a null, l'oggetto String originale diventa irraggiungibile. Il Collettore di Rifiuti libererà eventualmente questo oggetto, liberando la memoria che occupa.

Tipi di Collettori di Rifiuti

Java offre diversi tipi di collettori di rifiuti, ognuno con le sue peculiarità. È come avere diversi tipi di squadre di pulizia per diverse situazioni. Incontriamo le nostre squadre di pulizia:

Collettore di Rifiuti Seriale
Collettore di Rifiuti Parallelo
Collettore di Rifiuti Concurrente Mark Sweep (CMS)
Collettore di Rifiuti G1

Ecco una tabella pratica che riassume questi collettori:

Collettore di Rifiuti	Migliore Per	Caratteristica Chiave
Seriale GC	Ambienti single-threaded, set di dati piccoli	Semplice ed efficiente per applicazioni piccole
Parallelo GC	Ambienti multi-threaded, set di dati grandi	Si concentra sulla throughput
CMS GC	Applicazioni che richiedono tempi di pausa bassi	Operazione concorrente per minimizzare le pause
G1 GC	Grandi dimensioni dell'heap, tempi di pausa prevedibili	Divide l'heap in regioni per una raccolta efficiente

Generazioni nella Raccolta dei Rifiuti

Ora, parliamo di come Java organizza gli oggetti per la raccolta dei rifiuti. Java utilizza un modello di raccolta dei rifiuti generazionale, basato sull'osservazione che la maggior parte degli oggetti ha una breve durata della vita.

L'heap (dove vivono gli oggetti) è diviso in tre generazioni:

Generazione Giovane
Generazione Vecchia (chiamata anche Generazione Tenuta)
Generazione Permanente (sostituita da Metaspace in Java 8+)

Ecco un modo divertente per pensare a questo: Immagina una città con tre quartieri - Youngstown, Oldville e Permanentburg.

Generazione Giovane (Youngstown)

Questo è dove nascono i nuovi oggetti. È un luogo affollato e dinamico con un alto tasso di turnover. La maggior parte degli oggetti nasce e muore qui senza mai spostarsi in altri luoghi.

La Generazione Giovane è ulteriormente divisa in tre spazi:

Spazio Eden: Dove vengono allocati i nuovi oggetti.
Spazio dei Sobrevvitori 0 e Spazio dei Sobrevvitori 1: Dove vengono spostati gli oggetti che sopravvivono a una raccolta dei rifiuti.

Vediamo un esempio di creazione di oggetti nella Generazione Giovane:

public class EsempioGenerazioneGiovane {
public static void main(String[] args) {
for (int i = 0; i < 1000; i++) {
// Questi oggetti vengono creati nello spazio Eden
Object obj = new Object();
}
// La maggior parte di questi oggetti saranno raccolti nella prossima GC Minore
}
}

In questo esempio, stiamo creando 1000 oggetti. Questi saranno inizialmente allocati nello spazio Eden della Generazione Giovane.

Generazione Vecchia (Oldville)

Gli oggetti che sopravvivono a più raccolte dei rifiuti nella Generazione Giovane vengono promossi alla Generazione Vecchia. È come una comunità di pensionati per oggetti longevi.

Ecco un esempio di un oggetto che potrebbe finire nella Generazione Vecchia:

public class EsempioGenerazioneVecchia {
private static final ArrayList<String> longLivedList = new ArrayList<>();

public static void main(String[] args) {
for (int i = 0; i < 100000; i++) {
longLivedList.add("Item " + i);
// Questa lista sarà probabilmente promossa alla Generazione Vecchia
// man mano che cresce e sopravvive a più cicli di GC
}
}
}

In questo caso, longLivedList sarà probabilmente promossa alla Generazione Vecchia man mano che cresce e sopravvive a più cicli di raccolta dei rifiuti.

GC Minore

Il GC Minore è come una pulizia rapida di Youngstown. È veloce e si verifica frequentemente. Quando la Generazione Giovane si riempie, il GC Minore si attiva per pulirla.

Ecco cosa accade durante un GC Minore:

Tutti gli oggetti in Eden vengono spostati in uno dei spazi dei Sobrevvitori.
Gli oggetti dallo spazio dei Sobrevvitori corrente vengono spostati nell'altro spazio dei Sobrevvitori.
Gli oggetti che hanno sopravvissuto a diversi GC Minori vengono promossi alla Generazione Vecchia.

GC Completa

Il GC Completa è una pulizia più approfondita che copre sia Youngstown che Oldville. È più lento e meno frequente del GC Minore.

Un GC Completa viene attivato quando:

La Generazione Vecchia si riempie
Il Metaspace si riempie

Ecco un esempio che potrebbe innescare un GC Completa:

public class EsempioGCCompleta {
public static void main(String[] args) {
List<byte[]> list = new ArrayList<>();
while (true) {
// Alloca continuamente memoria
byte[] b = new byte[1024 * 1024]; // 1MB
list.add(b);
}
}
}

Questo programma alloca continuamente memoria senza rilasciarla. Alla fine, riempirà la Generazione Vecchia e innescare un GC Completa.

Regolazione dei Collettori di Rifiuti

Regolare i collettori di rifiuti è come affinare la vostra agenda di pulizia. È un argomento avanzato, ma ecco alcuni suggerimenti di base:

Scegliere il giusto collettore per la tua applicazione
Ajustare la dimensione dell'heap e delle generazioni
Impostare la registrazione GC appropriata

Ecco un esempio di come impostare il collettore di rifiuti e la dimensione dell'heap quando si esegue un'applicazione Java:

java -XX:+UseG1GC -Xmx4g -Xms4g MyApplication

Questo comando utilizza il Collettore di Rifiuti G1 e imposta sia la dimensione massima che iniziale dell'heap a 4GB.

Ricorda, la regolazione della raccolta dei rifiuti dipende fortemente dalla tua applicazione e ambiente specifici. È spesso un processo di sperimentazione e monitoraggio.

Eccoci qui, miei cari studenti! Abbiamo fatto un giro avventuroso della Raccolta dei Rifiuti di Java. Dall'understanding di cosa sia, all'esplorazione di diversi tipi di collettori e generazioni, fino a vedere come funzionano il GC Minore e il GC Completa, ora siete equipaggiati con le basi di questo aspetto cruciale della programmazione Java.

Ricorda, la Raccolta dei Rifiuti è come un'efficiente squadra di pulizia che lavora dietro le quinte dei tuoi programmi Java. Mentre fa il suo lavoro, puoi concentrarti sulla scrittura di codice straordinario. Buon coding, e possa la tua memoria essere sempre pulita e ordinata!

Credits: Image by storyset

Tutorial precedente:

Java - Formattazione Numeri Compact

Prossimo tutorial:

Java - Compilatore JIT