Standard Xmxsize in Java 8 (maximale Heap-Größe)

80

In der Orakel-Dokumentation fand ich:

-Xmxsize Gibt die maximale Größe (in Byte) des Speicherzuordnungspools in Byte an ... Der Standardwert wird zur Laufzeit basierend auf der Systemkonfiguration ausgewählt.

Was bedeutet Systemkonfiguration ?

java memory Vitaly
quelle
1
Wenn Ihr System über 16 GB RAM verfügt, ist die Größe größer als bei 512 MB.
JB Nizet
Danke, wie viel größer?
Vitaly
Geben Sie für „maximale Heap - Größe“ hier
Nir Alfasi
3
>> Kleiner als 1/4 des physischen Speichers oder 1 GB. Danke, @alfasin.
Vitaly
4
@Vitaly Das 1-GB-Limit scheint -Xmxzumindest in Java 8 nicht zu gelten, da ich auf meinem Linux-64-Bit-System mit einem Gesamtspeicher von 6 GB standardmäßig ein JVM mit -Xmx = 1,5 GB habe.
Eric Wang

Antworten:

142

Dies hängt von der Implementierung und Version ab, hängt jedoch normalerweise von der verwendeten VM (z. B. Client oder Server, siehe -clientund -serverParameter) und Ihrem Systemspeicher ab.

Oft für clientden Standardwert ist 1 / 4. Ihren physischen Speicher oder 1 GB (je nachdem , was kleiner ist).

Auch Java-Konfigurationsoptionen (Befehlszeilenparameter) können an Umgebungsvariablen einschließlich der "ausgelagert" werden -Xmx, die den Standard ändern können (dh einen neuen Standard angeben). Insbesondere wird die JAVA_TOOL_OPTIONSUmgebungsvariable von allen Java-Tools überprüft und verwendet, falls vorhanden (weitere Details hier und hier ).

Sie können den folgenden Befehl ausführen, um Standardwerte anzuzeigen:

java -XX:+PrintFlagsFinal -version

Es gibt Ihnen eine lange Liste, -Xmxist in MaxHeapSize, -Xmsist in InitialHeapSize. Filtern Sie Ihre Ausgabe (z. B. |grepunter Linux) oder speichern Sie sie in einer Datei, damit Sie darin suchen können.

icza
quelle
10
Als kleine Ergänzung können Sie java -XX:+PrintCommandLineFlagsdie von der JVM ausgewählten Heap-Größen (und andere Informationen) basierend auf den aktuellen Systeminformationen ausdrucken
Cristian Vat
1
@CristianVat Ja, aber der Parameter ist -XX:+PrintFlagsFinal, der von Ihnen vorgeschlagene funktioniert bei mir nicht. Hinzufügen zur Antwort.
icza
Richtig, Entschuldigung -XX:+PrintFlagsFinalist die beste Option, da alle Informationen angezeigt werden sollten, nachdem alles berücksichtigt wurde (einschließlich manueller Optionen und Ergonomie). Obwohl -XX:+PrintCommandLineFlagsscheint auf meiner JVM zu funktionieren (kann von der genauen Version abhängen)
Cristian Vat
2
Bei großen Boxen gilt diese Faustregel "1/4 RAM" definitiv nicht. Auf einem 4-Socket-Server mit 64 GB pro Socket (dh 256 GB RAM) ist Xmx standardmäßig ~ 32 GB. 32 GB können auch mit den Einschränkungen von CompressedOops in Zusammenhang stehen.
FauxFaux
2
Dies nur drucken Heap-Größe bezogene Zeilen:java -XX:+PrintFlagsFinal -version | grep HeapSize
Eric Wang
37

Wie Sie bereits erwähnt haben, -Xmxsizehängt die Standardeinstellung (Maximum HeapSize) von Ihrer Systemkonfiguration ab.

Java8 clientbenötigt mehr als 1/64 Ihres physischen Speichers für Ihre Xmssize(minimale HeapSize) und kleinere von 1/4 Ihres physischen Speichers für Ihre -Xmxsize(maximale HeapSize).

Das heißt, wenn Sie einen physischen Speicher von 8 GB RAM haben, haben Sie einen Xmssizegrößeren von 8 * (1/6) und einen kleineren von -Xmxsize8 * (1/4).

Sie können Ihre Standard-HeapSize mit überprüfen

In Windows :

java -XX:+PrintFlagsFinal -version | findstr /i "HeapSize PermSize ThreadStackSize"

Unter Linux :

java -XX:+PrintFlagsFinal -version | grep -iE 'HeapSize|PermSize|ThreadStackSize'

Diese Standardwerte können auch auf den gewünschten Betrag überschrieben werden.

Sarat Chandra
quelle
2
Referenz: docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/…
kisna
docs.oracle.com/javase/8/docs/technotes/guides/vm/… gemäß diesem Link ist die Standardeinstellung für Minimum / Initial 1/64 und nicht 1/6. "Größer als
1/64
15

Überraschenderweise hat diese Frage keine endgültige dokumentierte Antwort. Vielleicht würde ein anderer Datenpunkt anderen, die nach einer Antwort suchen, einen Wert bieten. Auf meinen Systemen mit CentOS (6.8.7.3) und Java 8 (Build 1.8.0_60-b27, 64-Bit-Server):

Der Standardspeicher ist 1/4 des physischen Speichers, nicht auf 1 GB beschränkt.

Auch -XX:+PrintFlagsFinaldruckt auf STDERR so Befehl aktuellen Standardspeicher von anderen präsentiert , um zu bestimmen oben sollte auf die folgenden gezwickt werden:

java -XX:+PrintFlagsFinal 2>&1 | grep MaxHeapSize

Folgendes wird auf einem System mit 64 GB physischem RAM zurückgegeben:

uintx MaxHeapSize                                  := 16873684992      {product}
brianNotBob
quelle
In meinem System mit 16 GB RAM: 2069889024 = 2 GB.
david.perez
Windows 7 64-Bit mit 8 GB RAM: 32-Bit-JVMs: 256 MB, 64-Bit-JVMs: 2 GB
Golimar
Endlich die Dokumentation dafür gefunden: stackoverflow.com/a/56036202/32453
rogerdpack
2

Auf meiner Ubuntu-VM mit 1048 MB Gesamt-RAM java -XX:+PrintFlagsFinal -version | grep HeapSizegedruckt uintx MaxHeapSize := 266338304:, was ca. 266 MB entspricht und 1/4 meines gesamten RAM beträgt.

Binita Bharati
quelle
2
Es sieht für mich so aus, als hätten OpenJDK und Oracle unterschiedliche Eigenschaften - ich sehe, dass OpenJDK immer 1/4 RAM als -Xmx verwendet (niemals kleiner als 1/4 und 1 GB)
pogul
1

Stand: 8. Mai 2019:

Die Größe des JVM-Heapspeichers hängt von der Systemkonfiguration ab. Dies bedeutet:

a) Client-JVM gegen Server-JVM

b) 32 Bit gegen 64 Bit .

Links:

1) Aktualisierung von J2SE5.0: https://docs.oracle.com/javase/6/docs/technotes/guides/vm/gc-ergonomics.html
2) kurze Antwort: https://docs.oracle.com/ javase / 8 / docs / technotes / guide / vm / gctuning / ergonomics.html
3) detaillierte Antwort: https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/parallel.html# default_heap_size
4) Client gegen Server: https://www.javacodegeeks.com/2011/07/jvm-options-client-vs-server.html

Zusammenfassung: (Es ist schwer von den obigen Links zu verstehen. Fassen Sie sie hier zusammen.)

1) Die standardmäßige maximale Heap-Größe für Client-JVM beträgt 256 MB (es gibt eine Ausnahme, die über die obigen Links gelesen wird).

2) Die standardmäßige maximale Heap-Größe für Server-JVM von 32 Bit beträgt 1 GB und von 64 Bit 32 GB (auch hier gibt es Ausnahmen. Bitte lesen Sie dies aus den Links).

Die maximale Größe des JVM- Heapspeichers beträgt also: 256 MB oder 1 GB oder 32 GB, abhängig von der obigen VM.

Vyshnav Ramesh Thrissur
quelle
1
Zum Schluss Links zu echten Dokumenten, die erklären, was los ist.
Rogerdpack