Quelle est la différence entre SoftReference et WeakReference en Java?

Références faibles sont collectées avec impatience. Si GC trouve qu'un objet est
faiblement accessible (accessible uniquement par le biais de références faibles), il va dégager la
la faiblesse des références à cet objet immédiatement. En tant que tels, ils sont bons pour
garder une référence à un objet pour lequel votre programme conserve également
(fortement référencé) "informations associées" quelque part, comme la mise en cache
la réflexion de l'information à propos d'une classe, ou un wrapper pour un objet, etc.
Tout ce qui n'a pas de sens de garder après l'objet auquel il est associé
avec GC-ed. Lorsque la référence faible est effacée, il obtient en file d'attente dans un
référence de la file d'attente de votre code sondages, quelque part, et il ignore l'
les objets associés ainsi. Qui est, vous gardez extra d'informations sur un
objet, mais que l'information n'est pas nécessaire une fois que l'objet qu'il désigne
s'en va. En fait, dans certaines situations, vous pouvez même sous-classe
WeakReference et de garder les associés de l'information supplémentaire à propos de l'objet
dans les domaines de la WeakReference sous-classe. Un autre exemple d'utilisation de
WeakReference est en conjonction avec des Cartes pour garder canonique instances.

SoftReferences d'autre part, sont bonnes pour la mise en cache externe, recreatable ressources
comme la GC généralement des retards de les effacer. Il est garanti bien que tous les
SoftReferences aurez effacé avant de OutOfMemoryError est levée, de sorte qu'ils
théoriquement, ne peut pas provoquer une OOME[*].

Cas d'utilisation typique exemple de garder un analysée forme d'un contenu à partir d'un
fichier. Vous auriez du mettre en place un système où vous chargez un fichier, l'analyser, et de garder
un SoftReference à la racine de l'objet de l'analyse de la représentation. La prochaine fois
vous avez besoin du fichier, vous allez essayer de le récupérer par la SoftReference. Si
vous pouvez le récupérer, vous vous épargner une autre charge/parse, et si le GC
effacé en attendant, vous le recharger. De cette façon, vous utiliser gratuit
mémoire pour l'optimisation des performances, mais ne prenez pas le risque d'une OOME.

Maintenant, pour le [*]. En gardant un SoftReference peut pas causer un OOME en lui-même. Si
d'autre part, par erreur, vous utilisez SoftReference pour une tâche d'une WeakReference est destiné
à être utilisé (à savoir, vous conservez les informations associées à un Objet en quelque sorte
fortement référencé, et le jeter lorsque l'objet de Référence obtient
désactivée), vous pouvez exécuter dans OOME que votre code qui interroge le ReferenceQueue
et supprime les objets associés peut arriver à ne pas s'exécuter dans un temps opportun
la mode.

Ainsi, la décision dépend de l'utilisation
- si vous êtes à la mise en cache de l'information qui est cher à construire, mais
néanmoins reconstructible à partir d'autres données, utiliser des références
- si vous êtes en gardant une référence à un exemple canonique de certaines données, ou
vous voulez avoir une référence à un objet sans être "propriétaire" (ce qui
la prévention de la GC avait), l'utilisation d'une référence faible.

Référence Faible
http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/ref/WeakReference.html

Principe: weak reference est liée à la collecte des déchets. Normalement, un objet ayant une ou plusieurs reference ne seront pas admissibles pour la collecte des ordures.

Le principe ci-dessus n'est pas applicable lorsqu'il est weak reference. Si un objet n'a qu'faible référence à d'autres objets, puis de son prêt pour la collecte des ordures.

Regardons l'exemple ci-dessous: Nous avons une Map avec des Objets où la Clé est de faire référence à un objet.

import java.util.HashMap;   
public class Test {

    public static void main(String args[]) {
        HashMap<Employee, EmployeeVal> aMap = new 
                       HashMap<Employee, EmployeeVal>();

        Employee emp = new Employee("Vinoth");
        EmployeeVal val = new EmployeeVal("Programmer");

        aMap.put(emp, val);

        emp = null;

        System.gc();
        System.out.println("Size of Map" + aMap.size());

    }
}

Maintenant, lors de l'exécution du programme, nous avons fait emp = null. Le Map en maintenant la touche n'a pas de sens ici, comme c'est null. Dans la situation ci-dessus, l'objet n'est pas de ces ordures.

WeakHashMap

WeakHashMap est celui où les entrées (key-to-value mappings) sera supprimé quand il n'est plus possible de les récupérer à partir de la Map.

Permettez-moi de montrer l'exemple ci-dessus, même avec WeakHashMap

import java.util.WeakHashMap;

public class Test {

    public static void main(String args[]) {
        WeakHashMap<Employee, EmployeeVal> aMap = 
                    new WeakHashMap<Employee, EmployeeVal>();

        Employee emp = new Employee("Vinoth");
        EmployeeVal val = new EmployeeVal("Programmer");

        aMap.put(emp, val);

        emp = null;

        System.gc();
        int count = 0;
        while (0 != aMap.size()) {
            ++count;
            System.gc();
        }
        System.out.println("Took " + count
                + " calls to System.gc() to result in weakHashMap size of : "
                + aMap.size());
    }
}

De sortie: a Pris 20 calls to System.gc() entraîner aMap size de : 0.

WeakHashMap a que de faibles références aux touches, pas de solides références à l'instar d'autres Map classes. Il y a des situations qui vous devez prendre soin lors de la valeur ou de la clé est fortement référencé, si vous avez utilisé WeakHashMap. Cela peut éviter par emballage de l'objet dans un WeakReference.

import java.lang.ref.WeakReference;
import java.util.HashMap;

public class Test {

    public static void main(String args[]) {
        HashMap<Employee, EmployeeVal> map = 
                      new HashMap<Employee, EmployeeVal>();
        WeakReference<HashMap<Employee, EmployeeVal>> aMap = 
                       new WeakReference<HashMap<Employee, EmployeeVal>>(
                map);

        map = null;

        while (null != aMap.get()) {
            aMap.get().put(new Employee("Vinoth"),
                    new EmployeeVal("Programmer"));
            System.out.println("Size of aMap " + aMap.get().size());
            System.gc();
        }
        System.out.println("Its garbage collected");
    }
}

Doux Références.

Soft Reference est légèrement plus forte que la faiblesse de référence. Soft de référence permet pour la collecte des ordures, mais soulève le garbage collector pour effacer uniquement si il n'y a pas d'autre option.

Le garbage collector n'est pas agressive recueillir doucement accessible objets de la manière qu'il le fait avec faiblement ceux qui sont accessibles -- au lieu de cela, il ne recueille doucement accessible objets si c'est vraiment "besoin" de la mémoire. Doux références sont une façon de dire que le garbage collector, "aussi longtemps Que la mémoire n'est pas trop serrée, j'aimerais garder cet objet autour de la. Mais si la mémoire devient vraiment serré, aller de l'avant et de les collecter et je vais y répondre." Le garbage collector est nécessaire pour effacer toutes les références avant de pouvoir lancer OutOfMemoryError.

SoftReference est conçu pour les caches. Lorsqu'il est constaté qu'un WeakReference références d'un objet inaccessible, elle sera effacé immédiatement. SoftReference peut être laissé tel qu'il est. Généralement, il existe un algorithme relatives à la quantité de mémoire disponible et l'heure de la dernière utilisation afin de déterminer si elle doit être effacée. Le courant de Soleil algorithme est d'effacer la référence si elle n'a pas été utilisé comme le nombre de secondes qu'il y a des méga-octets de mémoire libre sur le tas Java (configurable, serveur HotSpot les contrôles contre le maximum possible de segment défini par les -Xmx). SoftReferences seront supprimés avant de OutOfMemoryError est levée, sauf si accessible.

La Seule Vraie Différence

Par le doc, lâche WeakReferences doit être effacé par l'exécution d'un GC.

Par le doc, lâche SoftReferences doit être désactivée avant de OOM est levée.

C'est la seule vraie différence. Tout le reste ne fait pas partie du contrat. (Je pars du principe que les derniers documents sont contractuelles.)

SoftReferences sont utiles. La mémoire sensible caches utilisation SoftReferences, pas WeakReferences.

---

La seule bon utilisation de WeakReference est d'observer la GC exécuter. Pour ce faire, créez un nouveau WeakReference dont l'objet se met immédiatement hors de portée, puis essayer d'obtenir la valeur null de weak_ref.get(). Quand il est null, vous apprenez qu'entre cette durée, le GC a couru.

Comme pour incorrect utilisation de WeakReference, la liste est sans fin:

• moche hack pour mettre en œuvre la priorité-2 softreference de telle sorte que vous n'avez pas à écrire une, encore il ne fonctionne pas comme prévu, car le cache serait effacé sur chaque GC exécuter, même quand il n'y a de mémoire libre. Voir https://stackoverflow.com/a/3243242/632951 pour phails. (D'ailleurs, si vous avez besoin de plus de 2 niveaux de priorité de cache? Vous auriez dois encore avoir besoin d'une vraie bibliothèque pour elle.)

• moche hack pour associer des données à un objet d'une classe existante, encore il crée une fuite de mémoire (OutOfMemoryError) lorsque votre GC décide de prendre une pause après votre weakreferences sont créés. En outre, il est au-delà de laid: Une meilleure approche est d'utiliser des n-uplets.

• moche hack pour associer des données à un objet d'une classe existante, où la classe a le culot de faire elle-même non-subclassable, et est utilisé dans un fonction existante code dont vous avez besoin à appeler. Dans un tel cas, la bonne solution est de modifier la classe et de le rendre subclassable, ou de modifier la fonction et lui faire prendre une interface au lieu d'une classe, ou d'utiliser une autre fonction.

Il faut être conscient que faiblement objet référencé n'obtiendrez recueilli quand il ne dispose que de faibles référence(s). Si il a autant comme une référence forte, il n'est pas collectées n'importe comment beaucoup de références faibles qu'il possède.

Pour donner une action à l'utilisation de la mémoire aspect, j'ai fait une expérience avec une Forte, Douce, Faible & Fantôme références sous une lourde charge avec des objets lourds en conservant jusqu'à la fin du programme. Puis surveiller l'utilisation du tas de & GC comportement. Ces mesures peuvent varier au cas par cas, mais il donne certainement de haut niveau de la compréhension. Ci-dessous sont les résultats.

Tas & GC Comportement sous charge lourde

• Fort/Dur de Référence - Que le programme continue, la JVM ne pouvait pas recueillir conservé de solides objet référencé. Finalement en "java.lang.OutOfMemoryError: Java heap space"
• Doux de Référence - Que le programme continue, l'utilisation du tas ont continué à croître, mais le VIEUX gen GC qui s'est passé poule il s'approchait des tas max. GC a commencé peu plus tard dans le temps après le démarrage du programme.
• Référence faible - Que le programme a commencé, les objets ont commencé à finaliser & obtenir recueillies presque immédiatement. La plupart des objets ai recueillis dans la jeune génération de collecte des ordures.
• Fantôme de Référence - Similaire à la faiblesse de référence, le fantôme objets référencés aussi commencé à recevoir des finalisé & les ordures collectées immédiatement. Il n'y avait pas d'ancienne génération GC & tous les objets devenaient recueillies dans la jeune génération de collecte des ordures lui-même.

Vous pouvez obtenir de plus dans la profondeur des graphiques, des statistiques, des observations pour cette expérience ici.