Un Garbage Collector (GC) è un gestore di memoria. Molti linguaggi di programmazione hanno un GC integrato. Questa funzione alloca e dealloca automaticamente la memoria in un programma. Rilascia memoria occupata e inutilizzata che rallenta l'applicazione.

Il bello di un GC è che libera memoria per tuo conto, senza che tu debba fare nulla. Potresti, quindi, considerarla una caratteristica così essenziale che ti aspetteresti che ogni linguaggio di programmazione lo abbia. Purtroppo, questo non è il caso; anche un linguaggio popolare come il C può non avere un GC.

Come funziona l'allocazione della memoria?

Quando esegui un programma in qualsiasi linguaggio di programmazione, il tuo sistema operativo riserva a pila di dati in memoria per quel programma. Questo programma possiede e occupa questo stack di dati fino al completamento dell'esecuzione. Se il tuo programma ha bisogno di più memoria di quella disponibile, può allocare dinamicamente più memoria dall'heap di memoria del sistema operativo.

instagram viewer

Nella programmazione, una variabile rappresenta una locazione di memoria. Quindi, quando dichiari una nuova variabile, il linguaggio di programmazione alloca spazio in memoria per questa variabile. La variabile avrà ora un indirizzo di memoria. Fino a quando non assegni un valore a questa variabile, questa rimarrà non inizializzata e potrebbe contenere un valore spazzatura.

Se un linguaggio di programmazione consente di dichiarare una variabile senza inizializzarla, allora è una variabile dinamica. Ciò significa che il valore che assegni alla variabile potrebbe cambiare nel tempo. Tuttavia, la posizione di memoria della variabile rimarrà la stessa finché non la si dealloca.

Come funziona la deallocazione della memoria?

L'allocazione della memoria è un processo simile per tutti i linguaggi di programmazione. Ma il metodo corrispondente di deallocazione della memoria tende a differire. Esistono due tipi di metodi di deallocazione della memoria; manuale e automatico. Un GC esegue la deallocazione automatica.

Deallocation di memoria senza un Garbage Collector

Il Linguaggio di programmazione C non utilizza un GC per la deallocazione della memoria. Pertanto, i programmatori C devono allocare e deallocare manualmente la memoria. C consente l'allocazione dinamica della memoria per quando non si sa, in fase di compilazione, quanta memoria verrà utilizzata in fase di esecuzione.

La libreria standard (stdlib.h) contiene le funzioni che C utilizza per gestire l'allocazione dinamica della memoria. Queste funzioni includono:

  • malloc(): alloca una dimensione specifica di memoria e restituisce un puntatore a quella memoria. Se è disponibile memoria insufficiente nel pool di memoria del sistema operativo, restituisce null.
  • free(): dealloca uno specifico blocco di memoria e lo restituisce al pool di memoria del sistema operativo.

Esempio di programma C

#includere
#includere
intprincipale()
{
int *pt; // dichiara il puntatore
int j; // dichiara contatore


// alloca spazio per 200 numeri interi
 punto = (int *) malloc(200 * taglia di(int));


// inserisce valori interi nella memoria allocata
// e stampa ogni valore sulla console
per (j = 0; j < 200; j++)
 {
 ptr[j] = j;
stampa f("%d\t",ptr[j]);
 }
// dealloca la memoria precedentemente allocata
gratuito(ptr);
Restituzione0;
}

Il codice sopra alloca memoria per memorizzare 200 valori interi usando il malloc() funzione. Utilizza un puntatore per accedere a questa posizione di memoria e memorizza 200 valori interi al suo interno. Il puntatore stampa anche i dati archiviati nella posizione di memoria sulla console. Infine, il programma dealloca la memoria precedentemente allocata utilizzando il gratuito() funzione.

Deallocation di memoria con un Garbage Collector

Diversi linguaggi di programmazione popolari utilizzano un GC per la gestione della memoria. Questo rende la vita dei programmatori che usano questi linguaggi molto più facile. C# e Java sono due linguaggi di programmazione che utilizzano un GC.

Il C# GC

Nel Linguaggio di programmazione C#, un GC gestisce l'allocazione e la deallocazione degli indirizzi di memoria. Pertanto, un programmatore C# non deve preoccuparsi di deallocare un oggetto dopo aver completato il suo scopo.

Il C# GC inizializza un pool di memoria, chiamato heap gestito, per ogni nuovo processo (o programma). Chiama il Allocazione virtuale() funzione per allocare memoria e il VirtualFree() funzione per deallocarlo. La parte migliore è che tutto ciò accade in background senza alcuno sforzo da parte tua, il programmatore.

Il C# GC dispone di un motore di ottimizzazione, che utilizza per decidere quando deallocare la memoria. Il motore di ottimizzazione esamina la radice dell'applicazione per determinare quali oggetti non sono più in uso. Lo fa creando un grafico che si estende dalla radice dell'applicazione agli oggetti connessi. Questa radice include campi statici, variabili locali, ecc. Qualsiasi oggetto non connesso alla radice dell'applicazione è spazzatura.

Il motore di ottimizzazione GC non raccoglie solo memoria. Deve esserci prima una nuova richiesta di allocazione della memoria. Se il sistema ha una quantità ridotta di memoria disponibile, entrerà in gioco il motore di ottimizzazione GC.

Il Java GC

In Java, un GC gestisce anche l'allocazione e la deallocazione degli indirizzi di memoria. Tuttavia, Java ha attualmente quattro diversi tipi di Garbage Collector supportati:

  • Garbage-First (G1)
  • Seriale
  • Parallelo
  • Raccoglitore di rifiuti Z (ZGC)

Il Garbage Collector G1 è il GC predefinito di Java dal rilascio del Java Development Kit (JDK) 9. Java organizza i dati in oggetti e memorizza questi oggetti in un heap di dimensioni fisse. Il Garbage Collector G1 divide l'heap in regioni di heap di uguali dimensioni. Ha quindi diviso queste regioni dell'heap in due sezioni; giovani e vecchie generazioni.

Ogni volta che crei un nuovo oggetto, l'allocazione dello spazio per questo oggetto avviene nelle giovani generazioni. Utilizzando un processo di invecchiamento, il Garbage Collector G1 copia gli oggetti nelle regioni giovani nelle regioni vecchie. Copia anche gli oggetti che si trovano già nella vecchia regione in una vecchia regione.

Il Garbage Collector G1 esegue quindi la maggior parte della sua deallocazione della memoria nelle giovani generazioni, avventurandosi occasionalmente nella sezione della vecchia generazione.

Quali sono i vantaggi di avere un raccoglitore di rifiuti?

Il vantaggio di avere un Garbage Collector è che ti impedisce di pensare alla gestione della memoria mentre scrivi il tuo codice. Questo ti dà il tempo di concentrarti sugli altri aspetti importanti della tua applicazione. Tuttavia, vale la pena evidenziare molti altri vantaggi.

Il recupero di oggetti inutilizzati e la liberazione della memoria garantiscono un'esecuzione più pulita dell'applicazione. Se il tuo programma libera memoria il prima possibile, avrà un footprint di memoria inferiore e potrà funzionare in modo più efficiente.

Garbage Collection riduce gli errori relativi alla gestione della memoria, come le perdite e gli errori del puntatore. Questo perché il processo non dipende più dal programmatore e dalla sua capacità di scrivere codice accurato.