Discussion :

[vlakoff]

Bonjour,

Une question me préoccupe en ce moment, je me demande si le garbage collector en JavaScript est robuste (surtout que cela dépend des navigateurs...)

Mon exemple est le suivant : une fonction est appelée très fréquemment (plusieurs dizaines de fois par seconde). Cette fonction instancie une variable locale à chaque exécution (cf. code technique #1). À la sortie de cette fonction, la mémoire de la variable locale est théoriquement libérée. Le mécanisme de garbage collector est-il fiable à ce niveau ? Ou est-il préférable d'utiliser une instance unique de la variable, qui se situera dans le scope immédiatement supérieur ? (cf. code technique #2)

Je ne sais pas si ma question est claire, voire même pertinente... j'espère que l'exemple de code suivant sera plus parlant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
// - l'event "mousemove" est déclenché des dizaines (centaines ?) de fois par seconde
// - "maVariable" est utilisé uniquement dans la fonction déclenchée par le mousemove
// - les 2 techniques sont équivalentes en terme de vitesse d'exécution
 
// technique 1 : la variable est réinstanciée à chaque fois
// avantages : variable locale en accès direct, meilleure encapsulation
// inconvénient (a priori) : la mémoire est-elle toujours bien nettoyée ?
$(document).ready(function () {
	$('#monElement').mousemove(function (e) {
		var maVariable = uneFonction();
		// (...)
	});
});
 
// technique 2 : une seule instance de la variable
// avantage (a priori) : gestion mémoire plus sûre ?
// inconvénients : accès indirect à la variable, mauvaise encapsulation
$(document).ready(function () {
	var maVariable;
	$('#monElement').mousemove(function (e) {
		maVariable = uneFonction();
		// (...)
	});
});

j'attends vos avis

[RomainVALERI]

Il semble assez simple de faire un test à partir de tes deux exemples : fais la différence entre un new Date().getTime() avant et après 100000 appels de la fonction, une fois avec chaque version, compare les temps d'execution et tu verras clairement si c'est un facteur négligeable ou pas. ^^

Nous attendons tes résultats.

[vlakoff]

comme j'ai marqué en commentaire dans le code, les 2 techniques ont la même vitesse d'exécution

l'objet de la question, c'est est-ce qu'il y a un risque de fuite de mémoire avec la technique #1, ou est-ce que je m'inquiète pour rien ?

[sekaijin]

le garbage collector est efficace mais dépend du moteur javascript

c'est généralement une fonction JS exécuté dans un thread indépendant. donc pas d'impact sur le temps d'exécution

réutiliser la même variable économise les alloc de mémoire
mais sur de petits objet ça n'a aucun impacts.

je ne me souviens de fuite mémoire JS que dans les nightly builds. bien avant les versions Alfas.
nit sur FF ni sur JSCore je n'ai aucun souvenir dans les rapport de bug de fuite de ce type.

perso j'y fai confiance
sauf peut être pour IE qui ne donne aucune visibilité sur ce plan.

A+JYT

[Bovino]

Les fuites de mémoires sont effectivement possibles sur IE dans la mesure où pour des raisons "historiques", il possède deux garbage collectors distincts pour le DOM HTML et le DOM JavaScript.
Ces fuites de mémoire sont essentiellement dues à une mauvaise gestion des cross-references, donc typiquement des éléments du DOM HTML qui font référence à des événements (gérés par le DOM JavaScript) qui eux-mêmes font référence à des éléments HTML.

Ceci dit, il me semble que jQuery (sauf erreur) gère en interne ces problèmes pour éviter les fuites de mémoire sous IE. A condition bien sûr que la gestion des événements (et plus généralement du DOM) lui soit confié

[vlakoff]

merci pour ces réponses

donc apparemment mon idée de vouloir faire le moins d'instanciations possible n'est pas si mauvaise que cela...

[Watilin]

Il y a risque de fuites de mémoire sous IE seulement.
Dans le code #2, Le gestionnaire "mousemove" de #monElement fait une closure sur maVariable. Si, d’aventure, maVariable obtient une référence sur #monElement, on aura donc référence circulaire.

Mais comme le fait remarquer Bovino, jQuery se charge de nettoyer « manuellement » les gestionnaires d’évènements lors de la fermeture (unload) de la page. Donc si on utilise exclusivement jQuery pour lier les évènements, il n’y a pas de risque.

Donc à priori, les deux solutions sont équivalentes.
Après, il paraît que JavaScript fonctionne « en bulle », ce qui me laisse supposer qu’avec certains processeurs, deux appels successifs au mousemove peuvent se chevaucher légèrement. On aurait alors, avec le code #1, deux ou trois instances de maVariable en même temps, ce qui est quand même négligeable…