Coût de l'utilisation de références faibles en Java

Question

Quelqu'un a-t-il recherché les coûts d'exécution impliqués dans la création et la collecte des ordures Java WeakReference? Y a-t-il des problèmes de performances (par exemple, la contention) pour les applications multithreads?

EDIT: Il est évident que les réponses réelles dépendront de la JVM, mais les observations générales sont également les bienvenues.

EDIT 2: Si quelqu'un a fait un benchmarking de la performance, ou peut pointer vers des résultats d'étalonnage, ce serait idéal. (Désolé, mais la prime a expiré ...)

Answer 1

Les WeakReferences ont un impact négatif sur le garbage collector de CMS. Autant que je peux voir du comportement de notre serveur il influence le temps de phase de remarque parallèle. Pendant cette phase, tous les threads de l'application sont arrêtés, ce qui est extrêmement indésirable. Donc, vous devez faire attention avec WeakReferences.

Answer 2

La mise en cache à l'aide de références faibles peut ralentir considérablement votre application si elle est reconstruite à la demande, par ex. dans getters:

public Object getSomethingExpensiveToFind() { 
    if(cache.contains(EXPENSIVE_OBJ_KEY)) { 
     return cache.get(EXPENSIVE_OBJ_KEY); 
    } 

    Object sth = obtainSomethingExpensiveToFind(); // computationally expensive 
    cache.put(EXPENSIVE_OBJ_KEY, sth); 
    return sth; 
} 

imaginer ce scénario:

1) application est faible sur la mémoire

2) GC nettoie les références faibles, ce cache est effacé trop

3) application continue , beaucoup de méthodes comme getSomethingExpensiveToFind() sont invoquées et reconstruire le cache

4) l'application est à nouveau faible en mémoire

5) GC nettoie l'usure des références, efface le cache

6) l'application continue, beaucoup de méthodes comme getSomethingExpensiveToFind() sont invoquées et reconstruire le cache à nouveau

7) et ainsi de suite ...

Je suis tombé sur un tel problème - l'application a été interrompue par GC très souvent et il a complètement détruit tout le point de mise en cache. En d'autres termes, si elles sont mal gérées, les références faibles peuvent ralentir votre application.

Answer 3

J'ai implémenté un garbage collector Java une fois, donc tout ce que j'ai pu accomplir est une limite inférieure (faible) sur ce qui est possible.

Dans mon implémentation, il y a une petite quantité constante de surcharge supplémentaire pour chaque référence faible lorsqu'elle est visitée pendant la récupération de place. Donc, le résultat est le suivant: je ne m'inquiéterais pas, ce n'est pas un gros problème à moins d'utiliser des zillions de références faibles. Plus important encore, le coût est proportionnel au nombre de références faibles existantes, et non à la taille du tas global. Cependant, cela ne veut pas dire qu'un garbage collector prenant en charge les références faibles sera aussi rapide que celui qui ne le fait pas. La question supposée ici est, étant donné que Java supporte les références faibles, quel est le coût supplémentaire de leur utilisation?

Mine était un simple "stop the world" marque/balayage garbage collector.Lors de la récupération de place, elle détermine pour chaque objet si cet objet est actif ou non et définit un bit LIVE dans l'en-tête de l'objet. Ensuite, il passe à travers et libère tous les objets non vivants.

Pour gérer les références faibles que vous ajoutez simplement les éléments suivants:

• Ignorer les références faibles lors de la configuration LIVE bits (à savoir, ils ne causent pas le bit LIVE sur l'objet référencé à définir).
• Pendant l'étape de balayage, ajoutez une vérification spéciale comme suit: si l'objet que vous visitez est LIVE, et qu'il s'agit d'un WeakReference, cochez l'objet auquel il fait référence, et si cet objet n'est pas LIVE, effacez la référence .

De petites variations de cette logique fonctionnent pour les références logicielles et fantômes.

La mise en œuvre est here si vous êtes vraiment curieux.