Quels sont les types de références en Java et quelles sont leurs caractéristiques?

En Java, il existe trois principaux types de références (variables de référence), qui diffèrent dans le comportement du ramasse-miettes :

• Référence Forte (Strong Reference)
• Référence Douce (Soft Reference)
• Référence Faible (Weak Reference)
• Référence Fantôme (Phantom Reference)

Référence Forte (Strong Reference)

C'est le type de référence le plus courant. Un objet pointé par une référence forte ne sera pas collecté par le ramasse-miettes tant qu'au moins une référence forte à lui existe.

// Création d'un objet et d'une référence forte
Object myObject = new Object(); 

Référence Douce (Soft Reference)

Une référence douce pointe vers un objet qui peut être collecté par le ramasse-miettes si la JVM a besoin de mémoire. Les objets pointés uniquement par des références douces ne seront pas garantis d'être collectés tant que la JVM n'aura pas un besoin urgent de libérer de la mémoire. Utilisé souvent pour le cache.

import java.lang.ref.SoftReference;

// Création d'un objet
Object data = new Object(); 
// Création d'une référence douce à l'objet
SoftReference<Object> softRef = new SoftReference<>(data); 

// L'objet data peut être collecté si la mémoire manque
// Si l'objet n'a pas été collecté, il peut être récupéré
Object retrievedData = softRef.get(); 

Référence Faible (Weak Reference)

Une référence faible pointe vers un objet qui peut être collecté par le ramasse-miettes à tout moment si aucune référence forte ne le maintient. Les références faibles sont souvent utilisées pour implémenter des caches, où les éléments peuvent être supprimés en cas de manque de mémoire.

import java.lang.ref.WeakReference;

// Création d'un objet
Object cacheEntry = new Object(); 
// Création d'une référence faible à l'objet
WeakReference<Object> weakRef = new WeakReference<>(cacheEntry); 

// L'objet cacheEntry peut être collecté à tout moment
// Vérification si l'objet a été collecté
if (weakRef.get() == null) { 
    // L'objet a été collecté
}

Référence Fantôme (Phantom Reference)

Une référence fantôme est utilisée en conjonction avec ReferenceQueue pour effectuer des actions avant que l'objet ne soit complètement supprimé de la mémoire. Il est impossible d'obtenir l'objet via une référence fantôme (get() retourne toujours null). Utilisé principalement pour la gestion de ressources nécessitant un nettoyage particulier.

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

// Création d'un objet pour suivi
Object resource = new Object(); 
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>(); 
// Création d'une référence fantôme et liaison avec la file
PhantomReference<Object> phantomRef = new PhantomReference<>(resource, referenceQueue); 

// Dans un thread séparé, on peut surveiller la file referenceQueue
// Lorsque l'objet resource est prêt à être supprimé, la référence fantôme apparaîtra dans la file

Caractéristiques et comparaison :

Type de référence	Ramasse-miettes	Obtenir l'objet avec get()	Utilisation
Référence Forte	Pas de collecte	Oui	Usage normal
Référence Douce	Peut collecter	Oui (si pas collecté)	Caching (en cas de manque de mémoire)
Référence Faible	Peut collecter	Oui (si pas collecté)	Caching (si pas de références fortes)
Référence Fantôme	Peut collecter	Non (toujours null)	Nettoyage des ressources avant suppression (avec ReferenceQueue)