Java SE 8 Standard-Bibliothek  
Professionelle Bücher. Auch für Einsteiger.
 
Inhaltsverzeichnis


Vorwort
1 Neues in Java 8 und Java 7
2 Fortgeschrittene String-Verarbeitung
3 Threads und nebenläufige Programmierung
4 Datenstrukturen und Algorithmen
5 Raum und Zeit
6 Dateien, Verzeichnisse und Dateizugriffe
7 Datenströme
8 Die eXtensible Markup Language (XML)
9 Dateiformate
10 Grafische Oberflächen mit Swing
11 Grafikprogrammierung
12 JavaFX
13 Netzwerkprogrammierung
14 Verteilte Programmierung mit RMI
15 RESTful und SOAP-Web-Services
16 Technologien für die Infrastruktur
17 Typen, Reflection und Annotationen
18 Dynamische Übersetzung und Skriptsprachen
19 Logging und Monitoring
20 Sicherheitskonzepte
21 Datenbankmanagement mit JDBC
22 Java Native Interface (JNI)
23 Dienstprogramme für die Java-Umgebung
Stichwortverzeichnis

Jetzt Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Java SE 8 Standard-Bibliothek von Christian Ullenboom
Das Handbuch für Java-Entwickler
Buch: Java SE 8 Standard-Bibliothek

Java SE 8 Standard-Bibliothek
Pfeil 23 Dienstprogramme für die Java-Umgebung
Pfeil 23.1 Programme des JDK
Pfeil 23.2 Monitoringprogramme vom JDK
Pfeil 23.2.1 jps
Pfeil 23.2.2 jstat
Pfeil 23.2.3 jmap
Pfeil 23.2.4 jstack
Pfeil 23.2.5 jcmd
Pfeil 23.2.6 VisualVM
Pfeil 23.3 Programmieren mit der Tools-API
Pfeil 23.3.1 Java-Tools in Java implementiert
Pfeil 23.3.2 Tools aus eigenen Java-Programmen ansprechen
Pfeil 23.3.3 API-Dokumentation der Tools
Pfeil 23.3.4 Eigene Doclets
Pfeil 23.3.5 Auf den Compiler-AST einer Klasse zugreifen
Pfeil 23.4 Ant
Pfeil 23.4.1 Bezug und Installation von Ant
Pfeil 23.4.2 Das Build-Skript build.xml
Pfeil 23.4.3 Build den Build
Pfeil 23.4.4 Properties
Pfeil 23.4.5 Externe und vordefinierte Properties
Pfeil 23.4.6 Weitere Ant-Tasks
Pfeil 23.5 Disassembler, Decompiler und Obfuscator
Pfeil 23.5.1 Der Diassembler javap *
Pfeil 23.5.2 Decompiler
Pfeil 23.5.3 Obfuscatoren
Pfeil 23.6 Weitere Dienstprogramme
Pfeil 23.6.1 Sourcecode Beautifier
Pfeil 23.6.2 Java-Programme als Systemdienst ausführen
Pfeil 23.7 Zum Weiterlesen
 
Zum Seitenanfang

23.2Monitoringprogramme vom JDK Zur vorigen ÜberschriftZur nächsten Überschrift

Java ist eine beliebte Technologie auf der Serverseite, und da ist das Überwachen einer JVM sehr wichtig. Im bin-Verzeichnis vom JDK bringt Oracle daher eine ganze Reihe von Tools mit, von denen wir uns einige anschauen wollen.

 
Zum Seitenanfang

23.2.1jps Zur vorigen ÜberschriftZur nächsten Überschrift

Das Programm jps ist das Java Virtual Machine Process Status Tool und liefert alle laufenden Java-Programme mit einem lokalen VM-Identifizierer:

$ jps
3016 Jps
1111 org.eclipse.equinox.launcher_1.3.0.v20130327-1440.jar

Denkbare Optionen sind zum Beispiel:

  • -l listet den Paketnamen der Klasse mit dem main(String[]) auf.

  • -m zeigt die an die main(String[])-Methode übergebenen Argumente an.

  • -v und -V zeigen die an die JVM übergebenen Parameter an.

Mehr Details gibt es unter http://docs.oracle.com/javase/8/docs/technotes/tools/windows/jps.html.

jps selbst ist auch in der Liste. In dieser Sitzung ist die ID von Eclipse 1111. Die folgenden Beispiele nutzen die Eclipse-ID für zusätzliche Anfragen.

 
Zum Seitenanfang

23.2.2jstat Zur vorigen ÜberschriftZur nächsten Überschrift

Mit jstat, dem Java Virtual Machine Statistics Monitoring Tool, ist es möglich, Performance-Statistiken zu erfragen:

$ jstat -gcutil 1111
S0 S1 E O P YGC YGCT FGC FGCT GCT
0,00 0,00 0,41 46,19 99,43 42 0,575 278 56,867 57,442

Die Ausgaben zeigen zum Beispiel mit FGC die Anzahl der automatischen Speicherbereinigungsereignisse an. Die ID 1111 erfahren wir vom Tool jps. Die Seite http://docs.oracle.com/javase/8/docs/technotes/tools/windows/jstat.html schlüsselt die Abkürzungen auf.

 
Zum Seitenanfang

23.2.3jmap Zur vorigen ÜberschriftZur nächsten Überschrift

Das Memory-Map-Tool namens jmap zeigt eine Liste mit der Anzahl der Exemplare von Java-Objekten und zeigt auch, wie viel Hauptspeicher sie verbrauchen. Für Eclipse ist die Anzahl der Objekte sehr groß, sodass die Ausgabe hier gekürzt ist:

$ jmap -histo 1111

num #instances #bytes class name
----------------------------------------------
1: 103936 16083192 <constMethodKlass>
2: 98630 9517600 [C
3: 103936 8327696 <methodKlass>
4: 10042 6929984 <constantPoolKlass>
5: 10042 4533928 <instanceKlassKlass>
6: 8560 4067552 <constantPoolCacheKlass>
7: 85434 3901168 [B
8: 76434 1834416 java.lang.String
9: 64731 1553544 java.util.HashMap$Entry
10: 32035 1416784 [I
11: 10953 1292104 java.lang.Class
...
4409: 1 8 org.eclipse.jdt.internal.debug.ui....
4410: 1 8 org.eclipse.jdt.ui.actions.Organize...
4411: 1 8 org.eclipse.jdt.internal.corext.refactoring....
Total 818672 68628952

Weitere Details sind unter http://docs.oracle.com/javase/8/docs/technotes/tools/windows/jmap.html zu finden.

 
Zum Seitenanfang

23.2.4jstack Zur vorigen ÜberschriftZur nächsten Überschrift

Das Stack-Trace-Programm jstack zeigt laufende Threads an, zusammen mit Informationen über den durch Monitore erzwungenen Wartezustand. Ein Ausschnitt für die Eclipse-Threads:

$ jstack 1111
2011-08-12 15:51:37
Full thread dump Java HotSpot(TM) Client VM (21.0-b17 mixed mode, sharing):

"org.eclipse.jdt.internal.ui.text.JavaReconciler" daemon prio=2 tid=0x06214000 nid=0x30c4 in Object.wait() [0x069df000]
java.lang.Thread.State: TIMED_WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
– waiting on <0x19ff2978> (a org.eclipse.jface.text.reconciler.DirtyRegionQueue)
at ...

"Worker-28" prio=6 tid=0x06211400 nid=0xad0 in Object.wait() [0x0711f000]
java.lang.Thread.State: TIMED_WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
– waiting on <0x18b981c0> (a org.eclipse.core.internal.jobs.WorkerPool)
...
at org.eclipse.core.internal.jobs.Worker.run(Worker.java:50)

...

"[ThreadPool Manager] – Idle Thread" daemon prio=6 tid=0x06211c00 nid=0x295c in ¿
Object.wait() [0x08d7f000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
...
...

"Service Thread" daemon prio=6 tid=0x01f52000 nid=0x2d78 runnable [0x00000000]
java.lang.Thread.State: RUNNABLE

"C1 CompilerThread0" daemon prio=10 tid=0x01f36c00 nid=0x2b38 waiting on condition ¿
[0x00000000]
java.lang.Thread.State: RUNNABLE

"Attach Listener" daemon prio=10 tid=0x01f35800 nid=0x1788 waiting on condition ¿
[0x00000000]
java.lang.Thread.State: RUNNABLE

"Signal Dispatcher" daemon prio=10 tid=0x01f32400 nid=0x2ef8 runnable [0x00000000]
java.lang.Thread.State: RUNNABLE

"Finalizer" daemon prio=8 tid=0x01f2a400 nid=0x2004 in Object.wait() [0x044df000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
– waiting on <0x18997800> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(Unknown Source)
– locked <0x18997800> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(Unknown Source)
at java.lang.ref.Finalizer$FinalizerThread.run(Unknown Source)

"Reference Handler" daemon prio=10 tid=0x01f25000 nid=0x2ca8 in Object.wait() [0x043df000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
– waiting on <0x189974a0> (a java.lang.ref.Reference$Lock)
at java.lang.Object.wait(Object.java:503)
at java.lang.ref.Reference$ReferenceHandler.run(Unknown Source)
– locked <0x189974a0> (a java.lang.ref.Reference$Lock)

"main" prio=6 tid=0x01e19c00 nid=0x2b34 runnable [0x0012f000]
java.lang.Thread.State: RUNNABLE
at org.eclipse.swt.internal.win32.OS.WaitMessage(Native Method)
at org.eclipse.swt.widgets.Display.sleep(Display.java:4652)
...
at org.eclipse.equinox.launcher.Main.run(Main.java:1410)

"VM Thread" prio=10 tid=0x01f23c00 nid=0x28ec runnable

"VM Periodic Task Thread" prio=10 tid=0x01f5c000 nid=0x2898 waiting on condition

JNI global references: 373

Zum Stack-Trace der Threads gibt es weitere Informationen unter http://docs.oracle.com/javase/8/docs/technotes/tools/windows/jstack.html.

 
Zum Seitenanfang

23.2.5jcmd Zur vorigen ÜberschriftZur nächsten Überschrift

Mit dem Kommandozeilenprogramm jcmd lassen sich Diagnosekommandos zu einer laufenden JVM schicken.[ 153 ](http://docs.oracle.com/javase/8/docs/technotes/tools/windows/jcmd.html) Die Java-Programme werden wieder über eine PID identifiziert, die jcmd auch anzeigen kann:

$ jcmd.exe
1111 C:\Users\Christian\eclipse\\plugins/org.eclipse.equinox…
18868 sun.tools.jcmd.JCmd

Eclipse hat die PID 1111 und das Tool selbst – das bei jedem Starten natürlich eine neue PID bekommt – 18868.

Interessant wird jcmd dadurch, dass sich Diagnose-Kommandos senden lassen. Als Erstes steht die PID, dann folgt das Kommando. Um eine Übersicht über die Häufigkeit von geladenen Klassen zu bekommen, ist GC.class_histogram zu nutzen:

$ jcmd.exe 1111 GC.class_histogram
2484:

num #instances #bytes class name
----------------------------------------------
1: 600676 40906520 [C
2: 549996 13199904 java.lang.String
3: 121570 4862800 java.util.WeakHashMap$Entry
4: 117120 3747840 java.lang.ref.WeakReference
5: 63926 2730616 [Ljava.lang.String;

Auf der Hilfeseite sind die Kommandos nicht aufgeführt, weil sie abhängig von der jeweiligen JVM sind und nicht im Tool jcmd selbst verankert sind. Daher müssen sie dynamisch von einem laufenden Java-Programm erfragt werden. Unser Elcipse-Prozess hatte die PID 2484, und dann kommt die Option help zum Einsatz:

$ jcmd.exe 1111 help
1111:
The following commands are available:
VM.native_memory
VM.check_commercial_features
VM.unlock_commercial_features
ManagementAgent.stop
ManagementAgent.start_local
ManagementAgent.start
Thread.print
GC.class_stats
GC.class_histogram
GC.heap_dump
GC.run_finalization
GC.run
VM.uptime
VM.flags
VM.system_properties
VM.command_line
VM.version
help

For more information about a specific command use 'help <command>'.

Wie die letzte Zeile verrät, gibt ein angehängtes Kommando weitere Informationen, etwa

$ jcmd.exe 1111 help GC.heap_dump
1111:
GC.heap_dump
Generate a HPROF format dump of the Java heap.

Impact: High: Depends on Java heap size and content. Request a full GC unless
the '-all' option is specified.

Permission: java.lang.management.ManagementPermission(monitor)

Syntax : GC.heap_dump [options] <filename>

Arguments:
filename : Name of the dump file (STRING, no default value)

Options: (options must be specified using the <key> or <key>=<value> syntax)
-all : [optional] Dump all objects, including unreachable objects (BOOLEAN, false)
 
Zum Seitenanfang

23.2.6VisualVM Zur vorigen ÜberschriftZur nächsten Überschrift

VisualVM ist eine grafische Oberfläche mit einfachen Profiling-Möglichkeiten und bettet Kommandozeilenwerkzeuge wie jstack ein. VisualVM ist Teil vom JDK, aber eine aktuelle Version findet sich immer unter http://visualvm.java.net/. Im JDK befindet es sich wie die anderen Tools im bin-Verzeichnis und hört auf den Namen jvisualvm. Wir wollen die mitgelieferte Version nutzen. Beim ersten Mal müssen wir eine Kalibrierung starten, doch dann öffnet sich schon die grafische Oberfläche. Wählen wir links im Baum LocalVisualVM aus, so schauen wir uns die Zustände, etwa den Speicherbedarf und die Thread-Auslastung des Programms VisualVM selbst an (siehe Abbildung 23.1).

Durch den Speicher wühlen – Heap-Dump

Visual VM bietet die großartige Möglichkeit, sich während der Laufzeit zu einem Programm zu verbinden und über die Objektverweise zu navigieren. Unser Beispiel soll ein kleines Programm HeapUser sein, von dem wir später die vier Objektvariablen untersuchen wollen:

Screenshot der VisualVM

Abbildung 23.1Screenshot der VisualVM

Listing 23.1HeapUser.java

import java.util.*;

public class HeapUser {

String string = "Hallo Welt";
Date date = new Date();
ArrayList<String> list = new ArrayList<>(
Arrays.asList( string, date.toString() ) );
HeapUser heapUser;

public static void main( String[] args ) {
HeapUser h = new HeapUser();
h.heapUser = h;
new Scanner( System.in ).next();
System.out.println( h.string );
}
}

Starten wir das Programm und VisualVM läuft noch im Hintergrund, so erkennt VisualVM automatisch das gestartete Programm und aktualisiert die Baumansicht unter local.

Im Kontextmenü lässt sich über HeapUser der Heap-Dump erfragen.

Heap-Dump anzeigen

Abbildung 23.2Heap-Dump anzeigen

Nach dem Aktivieren des Schalters Classes sind alle geladenen Klassen aufgeführt, und es ist zu sehen, wie viele Exemplare es von den Klassen gibt.

Anzeige der geladenen Klassen mit Statistik

Abbildung 23.3Anzeige der geladenen Klassen mit Statistik

Unten gibt es ein Suchfeld, in welches wir »HeapUser« eintragen. Es bleibt eine Klasse in der Liste.

Suchen nach »HeapUser«

Abbildung 23.4Suchen nach »HeapUser«

Im Kontextmenü lässt sich nun Show in Instances View aufrufen.

Exemplare vom Typ HeapUser anfordern

Abbildung 23.5Exemplare vom Typ HeapUser anfordern

Die folgende Ansicht bildet den Ausgangspunkt für exploratives Arbeiten.

Attribute und Belegungen einsehen

Abbildung 23.6Attribute und Belegungen einsehen

Links ist die Instanz abgebildet, die wir untersuchen. Das ist HeapUser, von dem es genau ein Exemplar gibt (#1). Rechts gibt es zwei Einteilungen. In der oberen Einteilung können wir die Objekteigenschaften vom links ausgewählten Objekt sehen und durch die Baumansicht tiefer hineinzoomen. So enthält this, also das ausgewählte Objekt, die Variablen heapUser, list, date und string. An den auf sich selbst verweisenden Pfeilen an heapUser lässt sich – die Symbole werden in einer Art Statusleiste kurz erklärt – erkennen, dass die Variable heapUser das eigene Objekt referenziert. Falten wir list auf, so sehen wir die Objektvariablen der ArrayList-Instanz im Baum, und unter anderem lässt sich die size ablesen, also die Anzahl der Elemente in der Liste. elementData wiederum ist ein Knoten, der sich auffalten lässt, er repräsentiert das interne Feld – die eckigen Klammern deuten den Typ »Feld« an – der ArrayList. Wird er ausgefaltet, gelangen wir zu den beiden Strings. Im unteren Bereich der Einteilung, bei References, ist abzulesen, wer das selektierte Objekt referenziert. Es gibt zwei Stellen, an denen das untersuchte Objekt HeapUser referenziert wird: Einmal über die lokale Variable in der main-Methode, und einmal über die Objektvariable.

Profiling von Java-Applikationen

Ein Profiler zeigt an, an welchen Stellen ein Programm Prozessorzeit verbraucht. Auf der Webseite http://visualvm.java.net/profiler.html stellt Oracle eine Dokumentation bereit, wie VisualVM als Profiler genutzt wird.

 


Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.

<< zurück
 Zum Rheinwerk-Shop
Zum Rheinwerk-Shop: Java SE 8 Standard-Bibliothek Java SE 8 Standard-Bibliothek
Jetzt Buch bestellen

 Buchempfehlungen
Zum Rheinwerk-Shop: Java ist auch eine Insel
Java ist auch eine Insel


Zum Rheinwerk-Shop: Professionell entwickeln mit Java EE 8
Professionell entwickeln mit Java EE 8


Zum Rheinwerk-Shop: Besser coden
Besser coden


Zum Rheinwerk-Shop: Entwurfsmuster
Entwurfsmuster


Zum Rheinwerk-Shop: IT-Projektmanagement
IT-Projektmanagement


 Lieferung
Versandkostenfrei bestellen in Deutschland, Österreich und der Schweiz
InfoInfo

 
 


Copyright © Rheinwerk Verlag GmbH 2018. Original - https://www.rheinwerk-verlag.de/openbook/
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das Openbook denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt.
Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

 

 
 


29.09.2022 - Sitemap.xml