Gestion de la mémoire JVM------Introduction au garbage collector

Nous avons discuté de divers algorithmes GC dans le chapitre précédent, alors qu'est-ce qu'un garbage collector ?
En termes simples, en utilisant un langage de programmation pour implémenter un algorithme, le programme résultant est un ramasse-miettes. Maintenant que nous avons parlé de l'implémentation des langages de programmation, lorsque nous discutons du garbage collector, l'implémentation spécifique de la machine virtuelle a déjà été impliquée.
Peut-être que de nombreux développeurs JAVA ne savent pas que dans le JDK que nous utilisons habituellement, la JVM par défaut est hotspot. En d'autres termes, la JVM que nous utilisons la plupart du temps est la version d'implémentation de hotspot. dans LZ, cette fois-ci, tout est basé sur la version hotspot de JVM. Veuillez en être conscient.
De manière plus intuitive, nous pouvons entrer java -version pour vérifier la version JVM sur la machine que nous développons habituellement. Je pense que la plupart des amis singes connaissent cette commande. La capture d'écran de la machine de LZ est la suivante.

Classification des garbage collectors

Nous avons mentionné ci-dessus que les garbage collectors sont en fait des implémentations d'algorithmes dans un langage de programmation. Étant donné que les langages de programmation sont impliqués, les threads doivent être indissociables, et lorsque nous avons expliqué l'algorithme plus tôt, nous avons toujours supposé qu'un thread GC effectuait un travail GC.
Par conséquent, les éboueurs sont grossièrement répartis dans les trois catégories suivantes.
Collecteur série : il n'a qu'un seul thread GC et, comme mentionné précédemment, il doit mettre le programme utilisateur en pause (arrêter le monde) lors de son exécution.
Collecteur parallèle : il possède plusieurs threads GC et doit également mettre le programme utilisateur en pause (arrêter le monde).
Collecteur simultané : il possède un ou plusieurs threads GC et doit mettre le programme utilisateur en pause (arrêter le monde) à certaines étapes et exécuter une partie de l'étape en même temps que le programme utilisateur.

Concurrent et parallèle

Après avoir lu les définitions ci-dessus, je pense que certains amis singes ont été confus. Parfois, ils sont monothread, parfois multithread, et parfois en série, parfois parallèles. parfois simultanés, est-ce que tout cela n'a aucun sens ?
Pas besoin d'en dire plus sur le monothread et le multi-thread. C'est facile à comprendre. Le série et le parallèle sont également faciles à comprendre. Ce qui est difficile à distinguer est le parallèle et le concurrent.
Pour de nombreuses explications sur la concurrence, LZ pense qu'il y en a une qui est la plus appropriée. Cela s'explique de cette façon, la concurrence signifie que deux tâches A et B doivent s'exécuter indépendamment l'une de l'autre, et après le démarrage de la tâche A, la tâche B démarre avant la fin de la tâche A.
La concurrence elle-même est relativement facile à comprendre, alors quelle est sa relation et sa différence avec le parallélisme ?
En fait, le parallélisme est une méthode de mise en œuvre de la concurrence. LZ pense que vous comprendrez peut-être mieux en disant cela. Bien sûr, le parallélisme n'est pas le seul moyen d'obtenir la concurrence. Une autre façon est le changement de tranche de temps que nous connaissons. Autrement dit, la tâche A est exécutée pendant un certain temps, la tâche B est exécutée pendant un certain temps et exécutée en alternance.
Le parallélisme ne peut se produire que dans le cadre d'un multiprocesseur multicœur ou d'un système distribué (essentiellement toujours multiprocesseur multicœur), tandis qu'une exécution alternative ou une commutation de tranche de temps se produit sur un processeur monocœur.

Garbage collector dans hotspot

Nous avons brièvement discuté de la classification des garbage collector ci-dessus dans hotspotJVM, chaque type de garbage collector a une implémentation correspondante, comme suit.
Implémentation du collecteur série : série (utilisé dans la nouvelle génération, en utilisant l'algorithme de copie), série ancienne (utilisée dans l'ancienne génération, en utilisant l'algorithme de marquage/collation)
Implémentation du collecteur parallèle : ParNew (utilisé dans la nouvelle génération, en utilisant algorithme de copie), Parallel Scavenge (utilisé dans la nouvelle génération, en utilisant l'algorithme de copie), Parallel old (utilisé dans l'ancienne génération, en utilisant l'algorithme de marquage/collation)
Implémentation d'un collecteur concurrent : balayage de marque simultané[CMS] (utilisé dans l'ancienne génération, en utilisant l'algorithme mark/clear)
Comme vous pouvez le voir, chacun des garbage collector ci-dessus est conçu pour différentes zones de mémoire, car ils utilisent des algorithmes différents. Ils sont généralement utilisés dans la nouvelle génération. La génération utilise toutes l'algorithme de copie, et celles utilisées pour l'ancienne génération utilisent l'algorithme mark/clear ou mark/complement.
Dans les applications pratiques, nous devons sélectionner des garbage collectors pour la nouvelle génération et l'ancienne génération de la JVM. Nous pouvons voir qu'il existe trois implémentations pour la nouvelle génération et l'ancienne génération. 3 *3=9 choix. Cependant, ce n’est pas le cas.

En fait, il n'y a que six choix pour ces six éboueurs, car certains éboueurs ne peuvent pas travailler ensemble pour une série de raisons telles que des méthodes de mise en œuvre spécifiques, comme le montre la figure ci-dessous.

Pour l'image ci-dessus, le rouge est le collecteur série, le vert est le collecteur parallèle et le seul jaune est le collecteur simultané. Les trois premiers sont les collectionneurs de la nouvelle génération et les trois derniers sont les collectionneurs de l'ancienne génération. S’il existe un lien entre les deux, cela signifie qu’ils peuvent travailler ensemble.
Ces six combinaisons ne disent pas quelle combinaison est la plus forte et laquelle est la plus faible. Encore une fois, il n'y a que la plus appropriée, pas la meilleure. Par conséquent, nous devons avoir une certaine compréhension de chaque combinaison afin de choisir un ramasse-miettes plus approprié lors de son utilisation.

Conclusion

Ce qui précède est le contenu de la gestion de la mémoire JVM------introduction du garbage collector. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !