CMS Java jest ignorowany i uzyskuje pełne GC Zamiast tego

Question

Używam serwera Java, który używa CMS dla dzierżawionego kolektora. Działając pod obciążeniem, widzę młode kolekcje o każdej 1s i na stałe (równoczesne) co 5m. To jest dobre.

Kiedy biegnę z rzeczywistym ruchu około 1/2 pojemności, mam młodych zbiory o każdy 4S i zwyczajnych (! Równoległe, zatrzymać świat!) O każdym 7m. Dlaczego JVM decyduje się na zrobienie pełnych zatrzymań na świecie zamiast korzystania z kolektora CMS?

Z gc.log można zobaczyć „Full GC” prowadzony i przejmując 3s, aby zakończyć. Tutaj nie ma awarii w trybie równoczesnym. Nic wyraźnie nie żąda kolekcji.

1350.596: [GC 1350.596: [ParNew 
Desired survivor size 119275520 bytes, new threshold 3 (max 3) 
- age 1: 34779376 bytes, 34779376 total 
- age 2: 17072392 bytes, 51851768 total 
- age 3: 24120992 bytes, 75972760 total 
: 1765625K->116452K(1864192K), 0.1560370 secs] 3887120K->2277489K(5009920K), 0.1561920 secs] [Times: user=0.40 sys=0.04, real=0.16 secs] 
1355.106: [GC 1355.107: [ParNew 
Desired survivor size 119275520 bytes, new threshold 3 (max 3) 
- age 1: 44862680 bytes, 44862680 total 
- age 2: 20363280 bytes, 65225960 total 
- age 3: 16908840 bytes, 82134800 total 
: 1747684K->123571K(1864192K), 0.1068880 secs] 3908721K->2307790K(5009920K), 0.1070130 secs] [Times: user=0.29 sys=0.04, real=0.11 secs] 
1356.106: [Full GC 1356.106: [CMS: 2184218K->1268401K(3145728K), 3.0678070 secs] 2682861K->1268401K(5009920K), [CMS Perm : 145090K->145060K(262144K)], 3.0679600 secs] [Times: user=3.05 sys=0.02, real=3.07 secs] 
1361.375: [GC 1361.375: [ParNew 
Desired survivor size 119275520 bytes, new threshold 3 (max 3) 
- age 1: 33708472 bytes, 33708472 total 
: 1631232K->84465K(1864192K), 0.0189890 secs] 2899633K->1352866K(5009920K), 0.0191530 secs] [Times: user=0.19 sys=0.00, real=0.02 secs] 
1365.587: [GC 1365.587: [ParNew 
Desired survivor size 119275520 bytes, new threshold 3 (max 3) 
- age 1: 33475320 bytes, 33475320 total 
- age 2: 22698536 bytes, 56173856 total 
: 1715697K->67421K(1864192K), 0.0229540 secs] 2984098K->1335822K(5009920K), 0.0231240 secs] [Times: user=0.25 sys=0.00, real=0.03 secs] 

Oto flagi JVM:

-server -Xss256K -Xms5120M -Xmx5120M -XX:NewSize=2048M -XX:MaxNewSize=2048M 
-XX:SurvivorRatio=7 -XX:+UseConcMarkSweepGC -XX:+UseParNewGC 
-XX:+CMSParallelRemarkEnabled -XX:CMSInitiatingOccupancyFraction=80 
-XX:+UseCMSInitiatingOccupancyOnly -XX:CMSFullGCsBeforeCompaction=1 
-XX:SoftRefLRUPolicyMSPerMB=73 -verbose:gc -XX:+PrintGCDetails 
-XX:+PrintGCTimeStamps -XX:+PrintTenuringDistribution -Xloggc:logs/gc.log 
-XX:MaxPermSize=256m -XX:PermSize=256m -XX:MaxTenuringThreshold=3 

Answer 1

Jeśli przestrzeń przeżył nie jest wystarczająco duży, może to wywołać Pełny GC. (Wygląda na to, że narzeka na stosunek do przeżycia)

Albo musisz zmniejszyć współczynnik przeżycia, albo lepszym rozwiązaniem może być zwiększenie rozmiaru NewSize, aby mniej obiektów przetrwało z przestrzeni eden. Mam przestrzeń Eden 6 GB;)

Answer 2

wydaje mi się, przypominam sobie podobnego zjawiska w ubiegłym roku podczas strojenia dużej sterty uniknięcie pełnej GC. Myślę, że możesz chcieć zmniejszyć rozmiar eden. To dość duże w porównaniu do pokolenia na stałe.

co wierzę być może dzieje się to, że więcej od swojej eden dostaje „stary” w raz z 1/2 prędkości ruchu, niż ma to miejsce przy pełnej prędkości (w przypadku gdy nie są one przeżyły). Co oznacza, że ​​więcej trzeba przenieść na stałe na raz. A jeśli nie będzie pasować w tym czasie, może wywołać pełny GC, aby zrobić miejsce.

Dla odniesienia Oto co używamy teraz do 6GB na stosach 24GB:

-XX:NewRatio=4 -XX:SurvivorRatio=8 -XX:+UseCompressedOops 
-XX:+UseConcMarkSweepGC -XX:+UseParNewGC -XX:+DisableExplicitGC 
-XX:+UseCMSInitiatingOccupancyOnly -XX:+CMSClassUnloadingEnabled 
-XX:+CMSScavengeBeforeRemark -XX:CMSInitiatingOccupancyFraction=68 
-XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:logs/gc.log 

Jest dość podobny do Ciebie już. Zaletą korzystania ze wszystkich współczynników jest to, że można łatwo zmienić wielkość sterty i (ogólnie) odpowiednio skalować. Jeszcze jedna uwaga jest taka, że ​​-XX:+UseCompressedOops może zwykle zużywać o 40% mniej pamięci, redukując adresowanie 64-bitowe do 32-bitowych (działa tylko do 32 GB).