CIAO! Penso che non saresti molto sorpreso se ti dicessi che il tuo computer ha una quantità limitata di memoria :)
Anche il tuo disco rigido (che è molte, molte volte più grande della RAM) può essere pieno zeppo dei tuoi giochi preferiti, programmi TV e altre cose. Per evitare che ciò accada, è necessario monitorare lo stato corrente della memoria del computer ed eliminare i file non necessari. Come si collega tutto questo alla programmazione Java? Direttamente! Dopotutto, la creazione di qualsiasi oggetto fa sì che la macchina Java allochi memoria per esso . Un grande programma del mondo reale crea decine o centinaia di migliaia di oggetti e per ciascuno di essi viene allocata una porzione di memoria. Ma cosa ne pensi, quanti di questi oggetti esistono? Sono "vivi" per tutto il tempo in cui il nostro programma è in esecuzione? Ovviamente no. Nonostante tutti i loro vantaggi, gli oggetti Java non sono immortali :) Gli oggetti hanno il loro ciclo di vita. Oggi ci prenderemo una piccola pausa dalla scrittura del codice ed esploreremo questo processo :) È anche molto importante per capire come funziona un programma e per gestire le risorse. Allora, dove inizia la vita di un oggetto? Come un essere umano, dalla nascita, cioè quando viene creato.
Innanzitutto, la macchina virtuale Java alloca la memoria necessaria per creare l'oggetto. Quindi crea un riferimento ad esso (nel nostro caso, cat) per rendere possibile tenerne traccia. Quindi tutte le variabili vengono inizializzate, viene chiamato il costruttore e il nostro nuovo oggetto ora vive la propria vita :) Le vite degli oggetti variano. Non ci sono cifre esatte qui. In ogni caso, un oggetto vive nel programma ed esegue le sue funzioni per un certo periodo di tempo. Per essere precisi, l'oggetto è "vivo" finché ci sono riferimenti ad esso. Non appena non ci sono riferimenti, l'oggetto "muore". Per esempio:
public class Car {
String model;
public Car(String model) {
this.model = model;
}
public static void main(String[] args) {
Car lamborghini = new Car("Lamborghini Diablo");
lamborghini = null;
}
}
Nel main()metodo, l'oggetto Auto "Lamborghini Diablo" cessa di essere vivo sulla seconda riga. C'era solo un riferimento ad esso e il riferimento era impostato su null. Poiché non ci sono riferimenti rimanenti al Diablo, diventa "spazzatura". Un riferimento non deve essere impostato su zero affinché ciò accada:
public class Car {
String model;
public Car(String model) {
this.model = model;
}
public static void main(String[] args) {
Car lamborghini = new Car("Lamborghini Diablo");
Car lamborghiniGallardo = new Car("Lamborghini Gallardo");
lamborghini = lamborghiniGallardo;
}
}
Qui abbiamo creato un secondo oggetto e lo assegniamo alla referenza lamborghini. Ora due riferimenti puntano all'oggetto Lamborghini Gallardo, ma l' Lamborghini Diablooggetto non ne ha. Ciò significa che l' Diablooggetto diventa spazzatura. Questo è quando entra in gioco il Garbage Collector (GC) integrato di Java .
Il Garbage Collector è un meccanismo Java interno responsabile della liberazione della memoria, ovvero della rimozione dalla memoria di oggetti non necessari. C'è un motivo per cui abbiamo scelto di rappresentarlo con un robot aspirapolvere. Il Garbage Collector funziona più o meno allo stesso modo: si "sposta" nel tuo programma in background, raccogliendo i rifiuti. Praticamente non devi interagire con esso. Il suo compito è eliminare gli oggetti che non sono più utilizzati nel programma. Pertanto, libera memoria per altri oggetti. Ricordi che all'inizio della lezione abbiamo detto che nella vita reale devi monitorare lo stato del tuo computer ed eliminare i vecchi file? Se stiamo parlando di oggetti Java, il Garbage Collector lo fa per te. Il Garbage Collector viene avviato molte volte durante l'esecuzione del programma: non è necessario chiamarlo esplicitamente e dargli comandi (sebbene ciò sia tecnicamente possibile). Parleremo più approfonditamente del Garbage Collector in seguito e analizzeremo come funziona in modo più dettagliato. finalize()Quando il Garbage Collector raggiunge un oggetto, appena prima che venga distrutto, viene chiamato il metodo speciale dell'oggetto . Questo metodo può essere richiamato per rilasciare determinate risorse aggiuntive utilizzate dall'oggetto. Il finalize()metodo appartiene alla classe Object. In altre parole, è simile a equals(), hashCode()e toString()(che hai già incontrato). Ogni oggetto ce l'ha . Differisce dagli altri metodi in quanto...come dovremmo dire questo...è molto ostinato. Con questo intendiamo quellonon viene sempre richiamato prima che un oggetto venga distrutto . La programmazione è un'attività molto precisa. Il programmatore dice al computer di fare qualcosa e il computer lo fa. Presumo che tu ti sia abituato a questo tipo di comportamento, quindi all'inizio potrebbe essere difficile per te accettare la seguente idea: "Prima che un oggetto venga distrutto, viene chiamato il metodo della classe Object. Oppure no. Se siamo fortunati finalize()! " Eppure, questa è la realtà. La macchina Java stessa determina se chiamare finalize() caso per caso. Come esperimento, proviamo a eseguire il seguente codice:
public class Cat {
private String name;
public Cat(String name) {
this.name = name;
}
public Cat() {
}
public static void main(String[] args) throws Throwable {
for (int i = 0 ; i < 1000000; i++) {
Cat cat = new Cat();
cat = null;// The first object becomes available for garbage collection here
}
}
@Override
protected void finalize() throws Throwable {
System.out.println("The Cat is destroyed!");
}
}
Creiamo un Catoggetto e nella riga successiva azzeriamo l'unico riferimento ad esso. E lo facciamo un milione di volte. Abbiamo sovrascritto esplicitamente il finalize()metodo. Ogni volta che un Catoggetto viene distrutto, deve visualizzare una stringa, per un totale di un milione di volte. Ma no! Per essere esatti, sul mio computer è stato eseguito solo 37346 volte! In altre parole, la mia macchina Java ha deciso di chiamare il finalize()metodo solo in 1 caso su 27. Negli altri casi, la raccolta dei rifiuti non ha comportato questa chiamata. Prova a eseguire tu stesso questo codice. Molto probabilmente otterrai un risultato diverso. Come puoi vedere, è difficile chiamare finalize()un partner affidabile :) Quindi, ecco un piccolo consiglio per il futuro: non fare affidamento sul finalize()metodo per rilasciare risorse critiche.La JVM potrebbe chiamarlo o potrebbe non farlo. Chi lo sa? Se il tuo oggetto conteneva alcune risorse critiche per le prestazioni (ad esempio, una connessione al database aperta) mentre era attivo, sarebbe meglio creare e chiamare esplicitamente un metodo speciale per rilasciarle quando l'oggetto non è più necessario. In questo modo, saprai per certo che le prestazioni del tuo programma non ne risentiranno. Abbiamo iniziato dicendo che il lavoro con la memoria e la garbage collection sono argomenti molto importanti, e in effetti lo sono. La cattiva gestione delle risorse e l'incomprensione del modo in cui gli oggetti non necessari vengono ripuliti possono portare a uno dei bug più spiacevoli: perdite di memoria . Questo è uno degli errori di programmazione più noti. Ha anche il suo articolo su Wikipedia. Il codice scritto male può creare una situazione in cui la memoria viene allocata ogni volta per gli oggetti appena creati, ma gli oggetti vecchi e non necessari non sono disponibili per la raccolta dei rifiuti. Dato che abbiamo già fatto l'analogia con l'aspirapolvere robot, immagina cosa succederebbe se prima di far funzionare il robot spargessi calzini per tutta la casa, rompessi un vaso di vetro e lasciassi pezzi di Lego su tutto il pavimento. Naturalmente, il robot proverebbe a fare qualcosa, ma un giorno si blocca.
Affinché l'aspirapolvere funzioni correttamente, è necessario mantenere il pavimento in buone condizioni e raccogliere tutto ciò che non è in grado di gestire. Il Garbage Collector segue lo stesso principio. Se un programma ha molti oggetti che non può ripulire (come un calzino o un Lego per il nostro aspirapolvere robotico), un giorno finiremo la memoria. Non solo il tuo programma si bloccherà, ma anche tutti gli altri programmi che sono in esecuzione sul computer. Dopotutto, non avranno nemmeno abbastanza memoria (tornando alla nostra analogia, il vetro rotto sul pavimento ferma non solo l'aspirapolvere, ma anche le persone che vivono in casa). In breve, questo è l'aspetto del ciclo di vita degli oggetti e della raccolta dei rifiuti in Java. Non è necessario memorizzarlo: è sufficiente capire semplicemente come funziona. Nella prossima lezione, noi' Torneremo su questi processi in modo più dettagliato. Ma per ora, puoi tornare a risolvere i compiti di CodeGym :) Buona fortuna!
GO TO FULL VERSION