JVM-Parameter | Java-Leistungsoptimierung

Einführung

JVM-Parameter werden verwendet, um die Java Virtual Machine (JVM) zu konfigurieren, die für die Ausführung von Java-Bytecode verantwortlich ist. Indem wir die JVM-Parameter richtig konfigurieren, können wir die Leistung von Java-Anwendungen verbessern. In diesem Lab werden wir lernen, wie wir einige häufig verwendete JVM-Parameter festlegen, um die Leistung von Java-Anwendungen zu optimieren.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["Object-Oriented and Advanced Concepts"]) java(("Java")) -.-> java/FileandIOManagementGroup(["File and I/O Management"]) java(("Java")) -.-> java/ConcurrentandNetworkProgrammingGroup(["Concurrent and Network Programming"]) java(("Java")) -.-> java/SystemandDataProcessingGroup(["System and Data Processing"]) java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java/BasicSyntaxGroup -.-> java/output("Output") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/classes_objects("Classes/Objects") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/exceptions("Exceptions") java/FileandIOManagementGroup -.-> java/io("IO") java/ConcurrentandNetworkProgrammingGroup -.-> java/working("Working") java/SystemandDataProcessingGroup -.-> java/system_methods("System Methods") subgraph Lab Skills java/output -.-> lab-117968{{"Optimierung der Java-Anwendungsleistung"}} java/classes_objects -.-> lab-117968{{"Optimierung der Java-Anwendungsleistung"}} java/exceptions -.-> lab-117968{{"Optimierung der Java-Anwendungsleistung"}} java/io -.-> lab-117968{{"Optimierung der Java-Anwendungsleistung"}} java/working -.-> lab-117968{{"Optimierung der Java-Anwendungsleistung"}} java/system_methods -.-> lab-117968{{"Optimierung der Java-Anwendungsleistung"}} end

Heap-Speicher einstellen

Der Heap-Speicher ist der Laufzeitdatenspeicherbereich, in dem Java-Objekte zugewiesen werden. Wir können die Größe des Heap-Speichers mit den Parametern -Xmx und -Xms einstellen.

-Xmx<heap size>[unit]: Legt die maximale Heap-Größe fest.
-Xms<heap size>[unit]: Legt die Anfangsgröße des Heap-Speichers fest.

Beispielsweise können wir den folgenden Befehl verwenden, um die minimale Heap-Größe auf 512 MB und die maximale Heap-Größe auf 1 GB einzustellen:

java -Xms512m -Xmx1g MyApp

Wählen Sie einen Garbage Collector

Der Garbage Collection-Prozess ist der Prozess, bei dem der von Objekten belegte Speicher freigegeben wird, die von der Java-Anwendung nicht mehr verwendet werden. Die Wahl des Garbage Collectors kann einen signifikanten Einfluss auf die Leistung der Anwendung haben. Die JVM bietet mehrere Garbage Collector an, jeder mit seinen eigenen Stärken und Schwächen.

-XX:+UseSerialGC: Aktiviert den seriellen Garbage Collector, der einen einzelnen Thread für die Garbage Collection verwendet.
-XX:+UseParallelGC: Aktiviert den parallelen Garbage Collector, der mehrere Threads für die Garbage Collection verwendet.
-XX:+UseParNewGC: Aktiviert den concurrent-mark-sweep (CMS) Garbage Collector, der mehrere Threads verwendet, um die parallele Garbage Collection durchzuführen.
-XX:+UseG1GC: Aktiviert den Garbage-first (G1) Garbage Collector, der dazu ausgelegt ist, konsistente Pausenzeiten und hohe Durchsatzraten zu gewährleisten.

Beispielsweise können wir den folgenden Befehl verwenden, um den parallelen Garbage Collector zu aktivieren:

java -XX:+UseParallelGC MyApp

Protokollieren von Garbage Collection-Aktivitäten

Das Protokollieren der Garbage Collection ermöglicht es uns, die Leistung des Garbage Collectors zu überwachen und die Garbage Collector-Parameter gemäß den Anforderungen der Anwendung anzupassen. Wir können die folgenden Parameter verwenden, um das Protokollieren der Garbage Collection zu aktivieren:

-XX:+UseGCLogFileRotation: Aktiviert die Log-Umrotation für die Garbage Collection-Protokolle.
-XX:NumberOfGCLogFiles=<Anzahl der Log-Dateien>: Begrenzt die Anzahl der Log-Dateien für die Garbage Collection-Protokolle.
-XX:GCLogFileSize=<Dateigröße><Einheit>: Gibt die Größenbegrenzung für die Garbage Collection-Protokolle an.
-Xloggc:[Pfad zur gc.log-Datei]: Gibt den Pfad für die Garbage Collection-Protokolle an.

Beispielsweise können wir den folgenden Befehl verwenden, um das Protokollieren der Garbage Collection zu aktivieren und den Log-Dateipfad auf /path/to/gc.log zu setzen:

java -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=10M -Xloggc:/path/to/gc.log MyApp

Behandlung von Out-Of-Memory-Fehlern

Wenn die JVM den Speicher erschöpft, wirft sie einen Out-Of-Memory-Fehler. Wir können die folgenden JVM-Parameter verwenden, um diesen Fehler zu behandeln:

-XX:+HeapDumpOnOutOfMemoryError: Wenn ein Out-Of-Memory-Fehler auftritt, schreibt die JVM einen Heap-Dump auf die Festplatte.
-XX:HeapDumpPath=<Pfad zum Heap-Dump-File>: Gibt den Pfad für die Heap-Dump-Datei an.
-XX:OnOutOfMemoryError=<Befehl>: Wenn ein Out-Of-Memory-Fehler auftritt, führt die JVM den angegebenen Befehl aus.
-XX:+UseGCOverheadLimit: Die JVM verwendet diese Option, um eine Grenze für die Zeitspanne, die für die Garbage Collection verwendet wird, festzulegen.

Beispielsweise können wir den folgenden Befehl verwenden, um die JVM so zu konfigurieren, dass ein Heap-Dump in die Datei /path/to/heapdump.hprof geschrieben wird, wenn ein Out-Of-Memory-Fehler auftritt:

java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/path/to/heapdump.hprof MyApp

Verwenden der 64-Bit-JVM

Wir können den Parameter -d verwenden, um die 32-Bit- oder 64-Bit-JVM auszuwählen. Beispielsweise können wir den folgenden Befehl verwenden, um die 64-Bit-JVM zu verwenden:

java -d64 MyApp

Kompilieren und Ausführen einer Java-Anwendung mit JVM-Parametern

Lassen Sie uns das HelloWorld.java-Programm verwenden, um die Java-Anwendung mit den JVM-Parametern zu kompilieren und auszuführen, die wir in den vorherigen Schritten gelernt haben.

cd ~/project
touch HelloWorld.java
touch HelloWorld.java

Geben Sie folgenden Code ein:

class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Speichern Sie die Datei und beenden Sie den Editor. Nun kompilieren und führen wir den Code mit dem -Xmx-Parameter aus:

javac HelloWorld.java
java -Xmx512m HelloWorld

Dies setzt die maximale Heap-Größe auf 512 MB. Wir sollten die Ausgabe sehen:

Hello, World!

Kompilieren und Ausführen einer Java-Anwendung mit Garbage Collectors

Nun lassen Sie uns die Java-Anwendung mit dem parallelen Garbage Collector kompilieren und ausführen:

java -XX:+UseParallelGC HelloWorld

Wir sollten die Ausgabe sehen:

Hello, World!

Kompilieren und Ausführen einer Java-Anwendung mit Garbage Collection Logging

Nun lassen Sie uns die Java-Anwendung mit aktiviertem Garbage Collection Logging kompilieren und ausführen:

java -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=10M -Xloggc:/path/to/gc.log HelloWorld

Dies setzt den Log-Dateipfad auf /path/to/gc.log.

Kompilieren und Ausführen einer Java-Anwendung mit anderen häufig verwendeten Parametern

Nun lassen Sie uns die Java-Anwendung mit den Parametern -XX:+UseStringDeduplication und -XX:MaxHeapFreeRatio kompilieren und ausführen:

java -XX:+UseStringDeduplication -XX:MaxHeapFreeRatio=70 HelloWorld

Dies aktiviert die String-Deduplizierung und setzt das maximale Verhältnis von freiem Heap-Speicherplatz nach der Garbage Collection auf 70 %.

Zusammenfassung

In diesem Lab haben wir gelernt, wie verschiedene JVM-Parameter gesetzt werden, um die Leistung von Java-Anwendungen zu optimieren. Wir haben gelernt, wie die Größe des Heap-Speichers festgelegt wird, wie Garbage Collectors ausgewählt werden, wie das Garbage Collection Logging aktiviert wird, wie Out Of Memory Errors behandelt werden, wie die 64-Bit-JVM verwendet wird und wie einige andere häufig verwendete Parameter gesetzt werden. Wir haben auch gelernt, wie eine Java-Anwendung mit JVM-Parametern kompiliert und ausgeführt wird.