Quels sont les garbage collectors courants pour l’optimisation des performances Java ?

Éboueurs et algorithmes courants

Je pense que vous pouvez en apprendre beaucoup sur les éboueurs grâce aux deux autres articles que j'ai fournis. Les garbage collector auxquels nous devons vraiment prêter attention et que nous pouvons même utiliser sont les quatre types suivants :

garbage collector série en série

S'il se trouve dans une machine virtuelle de type client ou dans un single Sur les serveurs avec core, ce garbage collector deviendra le garbage collector par défaut. Qu'il s'agisse de Minor GC ou de Full GC, tous les threads d'application seront suspendus. Serial Old est utilisé dans l’ancienne génération, qui est également une version d’ancienne génération à thread unique. client型的虚拟机或者在单核的服务器上，这种垃圾回收器将会成为默认的垃圾回收器。无论是Minor GC 还是 Full GC ，所有的应用线程都会暂停。在老年代当中使用的是Serial Old，同样是单线程的老年代版本。

client型虚拟机，我们前面提到过编译类型分为client和server，jvm会通过client编译器（单线程）将代码编译成jvm识别的字节码。

可以通过如下标志表示：

    -XX:+UseSerialGC

Parallel 多线程垃圾收集器

在server型虚拟机或多线程服务器上，jdk8默认使用的垃圾收集器类型。

无论是Minor GC还是Full GC都使用多线程的方式去回收垃圾，这两种GC都会造成应用线程的暂停。但是它具有更多的吞吐量，是对于响应时间没有过多要求情况下，最合适的垃圾回收器。

可以通过如下标志查看其状态：

年轻代：

-XX:+UseParallelGC

老年代：

-XX:+UseParallelOldGC

CMS 收集器

其设计初衷是为了减少serial和parallel收集器，在回收时造成的长时间的系统卡顿。

它在发生Minor GC时同样会暂停所有的应用线程，不同之处在于，年轻代使用的不是parallel或者serial，而是使用一款专门适用于CMS的年轻代收集器ParNew。

可以通过下面的标志查看：

-XX:+UseParNewGC

CMS在发生Full GC时不再暂停全部应用线程，使用多线程的方式，和应用线程同时运行，清理不在使用的对象。这事得CMS垃圾收集器的停顿时间得到大大的降低。与Parellel收集器相比，极其明显。

缺点：

• CMS需要占用较多的CPU资源，确保在应用线程运行时，gc线程不断地扫描堆空间。

• 不会对内存进行压缩整理，导致内存碎片化。

如果没有足够的CPU资源，或者内存碎片化达到极限，将会退化成serial收集器。

可以通过下面的标志查看：

-XX:+UseConcMarkSweepGC

G1 收集器

也可以称作垃圾优先收集器(garbage first)。

设计初衷是为了尽量减少处理超大堆（4gb）时发生的卡顿。G1仍然属于分代收集器，但是不同之处是它是逻辑分代

Machine virtuelle de type client, nous avons mentionné plus tôt que le type de compilation est divisé en client et serveur. Le jvm compilera le code dans le bytecode reconnu par le jvm via le compilateur client (un seul thread).

peut être représenté par les drapeaux suivants :

-XX:+UseG1GC

Garbage collector multi-thread parallèle

Sur les machines virtuelles de type serveur ou serveurs multi-thread, le type de garbage collector utilisé par jdk8 par défaut.

Le GC mineur et le GC complet utilisent le multithreading pour collecter les déchets. Les deux types de GC entraîneront une pause du thread d'application. Mais il a un débit plus élevé et constitue le garbage collector le plus approprié lorsqu’il n’y a pas d’exigences excessives en matière de temps de réponse.

Vous pouvez vérifier son état grâce aux signes suivants :

Jeune génération :

System.gc;

Ancienne génération :

rrreeeCollecteur CMS

Sa conception originale est de réduire le temps causé par les collecteurs en série et en parallèle lors du recyclage. le système est bloqué.

• Il suspendra également tous les threads d'application lorsque Minor GC se produit. La différence est que la jeune génération n'utilise pas de parallèle ou de série, mais utilise un collecteur de jeune génération ParNew qui est spécifiquement adapté au code CMS>. <p></p>
Vous pouvez le vérifier avec le logo suivant :

• rrreee

  CMS ne suspend plus tous les threads d'application lorsque Full GC se produit. Il utilise le multi-threading pour s'exécuter en même temps que les threads d'application et nettoyer les objets qui ne le sont plus. utilisé. Cela réduit considérablement le temps de pause du garbage collector du CMS. Extrêmement évident par rapport au collector Parellel.

Inconvénients

 : 🎜🎜🎜🎜CMS doit occuper plus de ressources CPU pour garantir que lorsque le thread d'application est en cours d'exécution, le thread gc analyse en permanence l'espace du tas. 🎜🎜🎜🎜 ne compressera ni n'organisera la mémoire, ce qui entraînera une fragmentation de la mémoire. 🎜🎜🎜🎜S'il n'y a pas assez de ressources CPU, ou si la fragmentation de la mémoire atteint la limite, elle dégénérera en collecteur série. 🎜🎜🎜Peut être visualisé par le logo suivant : 🎜🎜rrreee🎜G1 collector🎜🎜Également connu sous le nom de Garbage first collector (garbage first). 🎜🎜La conception originale est de minimiser le décalage qui se produit lors du traitement de tas extrêmement volumineux (4 Go). G1 appartient toujours au collecteur générationnel, mais la différence est qu'il s'agit d'une génération logique. G1 divise l'espace du tas en plusieurs régions (régions). Le garbage collection dans la nouvelle génération utilise toujours la méthode de pause de tous les threads d'application pour copier les objets survivants vers l'ancienne génération ou l'espace Survivor. L'ancienne génération est également divisée en plusieurs zones, et le collecteur G1 termine le travail de nettoyage en copiant les objets d'une zone à une autre. Cela résout le problème de la fragmentation de la mémoire dans CMS. 🎜🎜Tout comme CMS, G1 est également un collecteur simultané. Lorsque Full GC se produit dans l'ancienne génération, le thread d'arrière-plan termine le travail de recyclage sans mettre en pause le thread d'application. 🎜🎜🎜Affichez à travers le logo suivant : 🎜🎜rrreee🎜En fait, le contenu ci-dessus est une simple description. Pour les détails réels de mise en œuvre, veuillez consulter l'article fourni au début. 🎜🎜Collection de poubelle explicite🎜🎜🎜La collecte de place explicite mentionnée ici fait en fait référence à une collecte de place déclenchée manuellement, comme indiqué ci-dessous : 🎜🎜rrreee🎜Il s'agit d'une sorte de contrôle qui permet à la JVM d'avoir forcé gc Way. Il n’est à aucun moment recommandé d’utiliser cette méthode pour le garbage collection. 🎜🎜Lorsque vous utilisez cette spécification, quel que soit le type de garbage collector, même CMS ou G1, un GC complet se produira et tous les threads d'application seront arrêtés en même temps, ce qui entraînera un décalage pendant une longue période. 🎜🎜🎜Exceptions : 🎜🎜🎜🎜🎜Analyse des performances, tests🎜🎜🎜🎜Analyse du tas🎜🎜🎜🎜Dans la situation ci-dessus, appeler System.gc nous aidera mieux à analyser les problèmes de l'application actuelle. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!