Effiziente Java Programmierung

Transkript

1 Effiziente Java Programmierung Seminar Implementierung moderner virtueller Maschinen am Beispiel von Java SS 2009 von Reinhard Klaus Losse 20. Mai 2009

2 Gliederung Definition Effizienz Werkzeuge zum Messen von Effizienz Beispiel aus der Praxis Mögliche Bösewichte Tests 2

3 1. Definition Effizienz Ein Programm ist effizient, wenn: seine Rechengeschwindigkeit niedrig ist, sein Speicherverbrauch niedrig ist und die Geschwindigkeit von Ein-/ Ausgabeoperationen niedrig ist. hier: Effizienz auf der Ebene der JVM und des Bytecodes 3

4 2. Messwerkzeuge Windows-Task-Manager äquivalente Tools in Unix/ Linux: top, ps, netstat, vmstat, iostat, sar (System Accounting Reports), truss, strace Profiler, z. B. Hprof Methoden java.lang.system.currenttimemillis() und java.lang.system.nanotime() (seit Java 5) 4

5 Profiler: Motivation geben z. B. Auskunft darüber: wie viele Objekte vom Typ X existieren, wie viel Speicher sie verbrauchen, wie Zeit ein Programm in Methode y verbringt und wie häufig diese Methode aufgerufen wurde 5

6 Geschichte von Hprof war in den Java-Versionen 1.2 bis 5 als Teil des experimentellen Java Virtual Machine Profiler Interface (JVMPI) enthalten wurde in Java 5 auf dem neuen Java Virtual Machine Tool Interface (JVM TI) implementiert, das das JVMPI ersetzte 6

7 Aufruf von Hprof bis Java 5: java -Xrunhprof[:options] ToBeProfiledClass ab Java 5: java -agentlib:hprof[=options] ToBeProfiledClass Liste aller Optionen: java -agentlib:hprof=help 7

8 Aufruf von Hprof Hprof speichert die Ergebnisse des Profilings in eine Datei jede Datei enthält: Liste aller Threads Liste von nummerierten Stacktraces 8

9 Aufruf von Hprof jede Datei kann darüber hinaus enthalten: Heap-Dump Liste aller Objekttypen geordnet nach dem Speicherverbrauch (Sites) Liste aller Methoden geordnet nach zeitlichen Stichproben (CPU Samples) Liste aller Methoden geordnet nach dem Zeitverbrauch (CPU Time) 9

10 Beispiel aus der Praxis String-Variante String hallowelt = Hallo Welt ; String weite = weite ; String hallo = hallowelt.substring(0, 7); String welt = hallowelt.substring(7); String halloweitewelt = hallo.concat(weite).concat(welt); 4 Objekte 10

11 3. Beispiel aus der Praxis StringBuffer-Variante String hallowelt = Hallo Welt ; String weite = weite ; StringBuffer stringbuffer = new StringBuffer(halloWelt); stringbuffer.insert(7, weite); String halloweitewelt = stringbuffer.tostring(); 3 Objekte 11

12 Beispiel aus der Praxis String-Variante mit + String hallowelt = Hallo Welt ; String weite = weite ; String hallo = hallowelt.substring(0, 7); String welt = hallowelt.substring(7); String halloweitewelt = hallo + weite + welt; 4 Objekte 12

13 Beispiel aus der Praxis Messergebnisse: String: ns 100% StringBuffer: ns 114% String mit +: ns 149% Einfügen von Strings erfolgt in Bezug auf den Zeitbedarf am besten mit der Klasse String 13

14 4. Mögliche Bösewichte Objekt mit vielen Instanzenvariablen Arrays mit vielen Elementen viele Methodenaufrufe häufige Arrayzugriffe häufige Feldzugriffe 14

15 Schleifen for (int i = 0; i < list.size(); i++) { Object o = list.get(i);... } for (int i = 0, n=list.size(); i < n; i++) { } Object o = list.get(i);... 15

16 Arrays private int arrayaccessinloop() { } int[] array = new int[1]; for (int i=0; i < ; i++) array[0] += i; return array[0]; 16

17 5. Tests Testsystem: Windows XP 1 GB Arbeitsspeicher Pentium M 1,86 Ghz Java 6 Durchführung der Tests fache Messung der Zeit über nanotime() 17

18 Objekt- und Arrayerzeugung Erzeugung eines Objekts mit nur einer int- Instanzenvariable Erzeugung eines Objekts mit 18 Instanzenvariablen, 9 int-variablen und 9 String-Variablen Erzeugung eines Arrays mit 0 Elementen Erzeugung eines Arrays mit 5 Elementen 18

19 Objekt- und Arrayerzeugung Messergebnisse: Objekt mit wenigen Elementen: 1955 ns 100% Objekt mit vielen Elementen: 2793 ns 143% Array mit 0 Elementen: 1676 ns 100% Array mit 5 Elementen: 1955 ns 117% 19

20 Methodenaufrufe facher Aufrufe folgender Methode: <Modifier> int mymethod(int j) { } return j+1; Modifier: public public static private private static 20

21 Methodenaufrufe Interface: Klasse implementiert ein Interface Interface enthält die Methode mymethod Oberklasse: Klasse erbt von Oberklasse 1. Variante: Klasse überschreibt mymethod 2. Variante: Klasse implementiert die abstrakte Methode mymethod facher Aufruf der Methode mymethod 21

22 Methodenaufrufe letzte Variante: inline for (int i = 0; i < ; i++) j = j + 1; direkte Ausführung der Operation statt Methodenaufruf 22

23 Methodenaufrufe Messergebnisse mit inline: public: ns 279% public static: ns 249% private: ns 359% private static: ns 249% abstrakt: ns 361% überschreiben: ns 279% Interface: ns 335% inline: ns 100% 23

24 Methodenaufrufe Messergebnisse ohne inline: public: ns 112% public static: ns 100% private: ns 144% private static: ns 100% abstrakt: ns 145% überschreiben: ns 112% Interface: ns 135% 24

25 Array- und Feldzugriff Zugriff auf das Arrayelement Nr. 10: int[] array = new int[100]; int j = 0; array[10] = 1; for (int i = 0; i < ; i++) j = j + array[10]; 25

26 Array- und Feldzugriff facher Zugriff auf ein Feld einer anderen Klasse: public public static facher Zugriff auf eine lokale Variable 26

27 Array- und Feldzugriff Messergebnisse: Arrayzugriff: ns 100% Feldzugriff (public): ns 107% Feldzugriff (public static): ns 101% Feldzugriff (lokal): ns 107% 27

28 Fazit Erzeugung größerer Objekte und Arrays dauert länger als die kleinerer inline bei Methodenaufrufen mit Abstand am schnellsten, gefolgt von statischen Methodenaufrufen private und abstrakt bei Methodenaufrufen am langsamsten, gefolgt von Interface Arrayzugriffe und statische Feldzugriff schneller als sonstige Feldzugriffe aber: JIT-Compiler bringt alles durcheinander 28

29 Quellen Performant Java programmieren, Hendrik Schreiber, Addison Wesley 2002 HPROF: A Heap/CPU Profiling Tool in J2SE 5.0, abgerufen am JDK 6 Documentation 29