Offizieller OIO-Seminar-Titel !
Werbung
Schneller fahren auf mehr Spuren? Multithreading im Zeichen von Mehrkernprozessoren Orientation in Objects GmbH Weinheimer Str. 68 68309 Mannheim Version: 1.2 www.oio.de [email protected] Steffen Schluff Papick Garcia Taboada Schneller fahren auf mehr Spuren? • Die neue bekannte Herausforderung • Multithreading und Enterprise Architekturen • Was tun als Programmierer ??? Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 2 Das Multi-Core Dilemma… Diskussionen gerade sehr aktuell Doug Lea … Brian Goetz java.util.concurrency Package … JSR 166, JDK 1.5 … Patrick Leonard Java Concurrency in Practice … Krieg der Kerne, iX … Blog von Patrick Leonard, Diskussion of TSS … Keynote von Tim Bray auf der WJAX 2006 … Verschiedene Sessions auf namhaften Konferenzen seitdem… Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH Tim Bray 3 Schluss mit Lustig? • Seit 30 Jahren konstanter CPU Performance Anstieg – Taktfrequenz, Ausführungsoptimierung, Cache – Sicherer Performance Gewinn für Software Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 4 2007 und noch immer keine Lösung… • CPU Taktfrequenz beginnt zu schwächeln – Bisheriger Trend endet circa 2004 – Probleme: Wärmeentwicklung, Stromverbrauch, Leckströme – Neue Ansätze versprechen immer wieder schnellere Prozessoren, bisher aber keine Produktionsreife erreicht • Free lunch is over? Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 5 Moore hat immer noch recht! • Wachstum der Transistordichte noch vorhanden (Moore‘s Law) • Hardware Hersteller satteln um – Hyperthreading, Caches – Multicore-Technik • braucht wenig Platz • kein völlig neues Design • günstigere Energiebilanz – Bei Erhöhung des Taktes steigt der Energiebedarf zum Quadrat – Bei Erhöung der Kerne steigt der Verbrauch „nur noch“ linear an Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 6 Wie sind die veränderten Prognosen für die Zukunft? • Cache Wachstum beschleunigt Anwendungen auch weiterhin • Aber Multithreading/Multicore beschleunigt Software nicht von selbst – Viele Anwendungen sind nicht für Mehrprozessorsysteme Entwickelt worden, laufen schließlich nur auf einem (meist langsameren Kern) Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 7 Wie läßt sich Hardware Wachstum weiter optimal nutzen? • Umdenken in der Entwicklung erforderlich • „Concurrent software“ wird zunehmend wichtig werden Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 8 Neue Herausforderungen für Software Entwickler • Neue Architekturen, APIs und Technologien • Umdenken im Bereich Testen und Performance Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 9 Offene Fragen, neue Problemstellungen „No matter how great and destructive your problems may seem now, remember, you've probably only seen the tip of them“ Increasing success by lowering expectations http://www.despair.com Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 10 Multithreading, ist das was neues? Wikipedia, Multithreading Der Begriff Multithreading (auch Mehrfädigkeit) bezeichnet das zeitgleiche Abarbeiten mehrerer Threads (das sind Ausführungsstränge innerhalb eines einzelnen Prozesses oder eines Tasks). Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 11 Java Buzzwordbingo! The Java programming language is a high-level language that can be characterized by all of the following buzzwords: Simple Architecture neutral Object oriented Portable Distributed High performance Multithreaded Robust Dynamic Secure Quelle: The Java Tutorials, The Java Technology Phenomenon Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 12 Java Buzzwordbingo! The Java programming language is a high-level language that can be characterized by all of the following buzzwords: Simple Architecture neutral Object oriented Portable Distributed High performance Multithreaded Robust Dynamic Secure Quelle: The Java Tutorials, The Java Technology Phenomenon Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 13 Also… Java kann doch Multithreading! • Java unterstützt seit Beginn Multithreading – – – – – – – synchronized, volatile wait() notify() notifyAll() Collections.synchronized[Collection|List|Set|Map](…) U.s.w. … Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 14 Aber… Können wir es? • In der Praxis aber schwer anwendbar – Multithread Programmierung syntaktisch einfach, aber keineswegs trivial! – Komplizierte Konstrukte mit niedrigem Abstraktionsgrad – In reiner Form ungeeignet für Anwendungsentwicklung Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 15 Wie gut ist die eigene Lösung? • Jeder kocht sein eigenes Süppchen – Viele hausgemachte Ad-Hoc Lösungen – Eigene Lösungen oft unausgegoren und nur schwer testbar Î Einarbeitungszeit für neue Mitarbeiter? Î Testbarkeit? Î Dokumentation? Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 16 Java, Threads und… CPUs? Angenommen, wir (Entwickler) sind in der Lage Concurrent Software zu entwickeln, wie werden meine Threads auf CPUs verteilt? Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 17 Mehrere CPUs in Java nutzen • Java stellt keine eigene Funktionen zur Prozesskontrolle und Prozesssteuerung bereit Verschiedene Arten von Threads (aus Sicht der VM) – Je nach OS verschiedene Ansätze – OS Frage als Platform (wieder) Aktuell? Multithreading im Zeichen von Mehrkernprozessoren Green Threads Threads „nur innerhalb“ einer VM Native Threads (heute Standard) Java Threads werden auf Betriebsystemprozesse abgebildet Betriebsystem ist für Scheduling zuständig © 2007 Orientation in Objects GmbH 18 CPU Affinity? Bug ID: 4234402 Synopsis: (thread) Thread.setCPUAffinity? State: Closed, will not be fixed (…) But this is ignoring the basic fact that only the most sophisticated Java users could expect to gain real advantage with such a feature (i.e. by making better scheduling choices than the operating system would make without use of the feature) (…) Quelle: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4234402 Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 19 Java & Windows • Native Threads sind Win32 Threads – Windows ist für Scheduling und Synchronization zuständig – Tools zur Überwachung sind im Windows Softwareumfeld zu suchen – „Leistung“ (perfmon.msc) bietet viele Überwachungsmöglichkeiten Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 20 Visualisierung mit Perfmon.msc Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 21 Schneller fahren auf mehr Spuren? • Die neue bekannte Herausforderung • Multithreading und Enterprise Architekturen • Was tun als Programmierer ??? Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 22 Wo helfen viele Prozessoren? • Virtualisierung von Rechnern – Xen, VM Ware, OpenVZ, u.v.a. • Erhöhung der Performance einzelner Server bzw. Dienste die bereits Multithreaded sind – Application Server – Mail Server – U.s.w. Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 23 Eigentlich nichts Neues • „Enterprise“ Hardware schon seit längerer Zeit Multiprozessorbasiert – Symmetrisches Multiprocessing ist seit Ende der 80er Jahre die Standard-Architektur für Multiprozessor-Maschinen mit bis zu 16 CPUs. • Java Enterprise Edition adressiert thread safety und concurrency bereits in der Architektur • Warum also erst jetzt die ganze Diskussion? Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 24 Hardware… Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 25 Und (Enterprise) Software… • Java wird stark im Umfeld Unternehmenskritischer Anwendungen eingesetzt – Java Enterprise Edition • Java EE Architekturen vereinfachen die Softwareentwicklung - Laufzeitumgebung Schnittstellen Programmiermodell Vorschriften bzw. Restriktionen Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 26 Java EE Architektur, EJBs The Enterprise JavaBeans architecture will make it easy to write applications: application developers will not have to understand low-level transaction and state management details, multi-threading, connection pooling, or other complex low-level APIs. The enterprise bean must not attempt to manage threads. The enterprise bean must not attempt to start, stop, suspend, or resume a thread, or to change a thread’s priority or name. The enterprise bean must not attempt to manage thread groups. These functions are reserved for the EJB container. Allowing the enterprise bean to manage threads would decrease the container’s ability to properly manage the runtime environment. Quelle: Enterprise JavaBeans 3.0 Final Release Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 27 Java EE Architektur The Enterprise JavaBeans architecture will make it easy to write applications: application developers will not have to understand low-level transaction and state management details, multi-threading, connection pooling, or other complex low-level APIs. The enterprise bean must not attempt to manage threads. The enterprise bean must not attempt to start, stop, suspend, or resume a thread, or to change a thread’s priority or name. The enterprise bean must not attempt to manage thread groups. These functions are reserved for the EJB container. Allowing the enterprise bean to manage threads would decrease the container’s ability to properly manage the runtime environment. Quelle: Enterprise JavaBeans 3.0 Final Release Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 28 Java EE und „thread safety“ • Prinzipiell sorgt ein Application Server dafür, dass die Komponenten sich nicht um „thread safety“ kümmern müssen – Das bezieht sich aber nur auf EJBs • z.Bsp. werden SLSB werden mehrfach instanziert um exklusivität (und dadurch Threadsafety) während eines Methodenaufrufs zu garantieren – Servlets sind Singletons und werden u.U. von verschiedenen Threads gleichzeitig aufgerufen, müssen also Threadsafe sein. • Thread Synchronization ist keine Lösung • Das Interface SingleThreadModel ist „deprecated“ seit Servlet API 2.4 Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 29 Java EE und „thread safety“ Fazit Nur EJB Anwendungen sind „out of the box“ thread safe – Gut: • Entwickler muss sich nicht um Threads und Threadsafety kümmern • Anwendung skaliert in Bezug auf Anzahl der Anfragen/ Clients ohne zutun des Entwicklers – Schlecht: • Entwickler kann keine Threads starten und somit keine Lösungsansätze anstreben, die Nebenläufigkeit einbeziehen • Anwendung skaliert nicht in Bezug auf Komplexität der Businesslogik wenn sequentielle Algorithmen versagen Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 30 Problembereich Webanwendungen • Thread safety in Webanwendungen nicht immer gegeben – „Wir brauchen keine EJBs. Wir wollen nur eine einfache Webanwendung bauen“ • Anmerkung: Es gibt nicht sowas wie eine „Einfache Webanwendung“ – Viele Webanwendungen verzichten auf EJB-Schicht – Entwickler müssen sich mit „thread safety“ auseinandersetzen • Was kümmer mich „thread safety“? Bin doch J2EE Entwickler… • „Know How“ vorhanden? Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 31 Ist Spring die Rettung? • Teilweise… Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 32 Solving other peoples‘ problems… Die mit Spring mitgelieferten „Data Access Templates“ sind thread safe. - Problembereich Hibernate! Dadurch wird die Implementierung einer DAO Schicht innerhalb einer Webanwendung deutlich vereinfacht. Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 33 Vorsicht… • Die in Spring konfigurierte business Schicht (services) müssen je nach Umfeld „thread safe“ entwickelt werden. • Dennoch muss sich ein Entwickler mit der Tatsache auseinandersetzen, dass thread safety in einer Webanwendung nicht gegeben ist und das entsprechende Know How aufbauen Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 34 Project Danger? Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 35 Schneller fahren auf mehr Spuren? • Die neue bekannte Herausforderung • Multithreading und Enterprise Architekturen • Was tun als Programmierer ??? Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 36 Der Silberstreifen am Horizont • Pionierarbeit durch Doug Lea – Web Page und Veröffentlichungen seit Ende der 90er – Entwicklung eigener Java API (EDU.oswego.cs.dl.util.concurrent) • Einrichtung JSR 166 – „... provide functionality commonly needed in concurrent programs.“ – Geleitet durch Doug Lea • Ergebnis „Concurrency Utilities“ – Seit Java 5 fest im JDK (java.util.concurrent) – Etwas untergegangen im Sprachfeature Trubel – Diverse Erweiterungen in Java 6 Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 37 Concurrency Utilities Bestandteile (1) • Stellt fertige Bausteine zur Verfügung – Für alle Arten von Entwicklern (Anwendung, Server, Concurrent, ...) • Concurrent Collections – Spezielle Implementierungen von Map, Set, List, Queue, Deque • Executor Framework – Framework zur Ausführung asynchroner Tasks Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 38 Concurrency Utilities Bestandteile (2) • Synchronizers – Hilfsklassen zur Koordination mehrerer Threads – Semaphore, CountDownLatch, CyclicBarrier, Exchanger • Locks und Conditions – Lock ist Objekt Repräsentation von synchronized – Condtion kapselt Monitor Methoden wait(), notify und notifyAll() • Atomic Variables – Atomare Manipulation einzelner Variablen – Erlaubt Hardware Compare-And-Swap (CAS) zu nutzen Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 39 Klassiker • „Thread-Safe“ Datenstrukturen in Java bereits vorhanden – Vector, Hashtable – Synchronized Wrapper aus java.util.Collections: synchronizedList(), ... • Sicherheit durch Synchronisierung aller Zugriffsmethoden – Grob granulares Locken der ganzen Collection – Skaliert schlecht bei Zugriff aus vielen Threads („Multicore anyone?“) • Synchronisierung durch Client häufig notwendig – Mehrschrittige Operationen (deleteLast, putIfAbsent, ...) – „Fail-fast“ Iteratoren (ConcurrentModificationException) Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 40 Überraschung List<String> ls = Collections.synchronizedList(new ArrayList<String>()); ... // Verhalten kann undeterministisch sein // Kann ConcurrentModificationException werfen Iterator<String> i = ls.iterator(); while (i.hasNext()) { foo(i.next()); } ... Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 41 Gut Ding will Weile haben List<String> ls = Collections.synchronizedList(new ArrayList<String>()); ... // Client synchronisiert // Blockiert anderen Zugriff während Iteration synchronized(ls) { Iterator<String> i = ls.iterator(); while (i.hasNext()) { foo(i.next()); } } ... Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 42 Concurrent Collections • Unterscheidung „Thread-Safe“ und „Concurrent“ – Neue Implementierungen der klassischen Strukturen (List, Map, Set) – Ab Java 6 auch für SortedMap und SortedSet • Erlauben nicht blockierenden (skalierbaren) parallelen Zugriff – Standardfall: Paralleles Lesen aus mehreren Threads – Nachteil: Kleinere semantische Anpassungen notwendig • Iteratoren „weakly consistent“ statt „fail-fast“ – Kein komplettes Locken und keine ConcurrentModificationException – Iterator darf Änderungen seit seiner Erzeugung ignorieren Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 43 Klassiker, again • ConcurrentHashMap – Fein granulareres Locken erlaubt paralleles Lesen und Schreiben – Kein Client-Lock, dafür neue atomare Methoden (putIfAbsent, ...) • CopyOnWriteArrayList / CopyOnWriteArraySet – Array basierte Liste, Veränderung führt zu neuer Array Kopie – Ideal falls lesen deutlich häufiger als schreiben • ConcurrentSkipListMap (ab Java 6) – Implementierung des SortedMap Interface – Wird auch verwendet für ConcurrentSkipListSet Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 44 Neuzugänge vorne anstellen • Neues Collection Interface Queue – Datenstruktur, die Elemente für eine Verarbeitung bereit hält • Neues Collection Interface BlockingQueue – Methoden take() und put(), die bei leerer / voller Queue blockieren – Für Erzeuger-Verbraucher Architekturen (z.B. Thread Pools) • Neue ColIection Interfaces Deque und BlockingDeque (ab Java 6) – Deque steht für Double Ende QUEue – Für „Work Sharing“ und „Work Stealing“ Architekturen Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 45 Executor Framework (1) • Ermöglicht asynchrones Ausführen von Tasks in Thread Pools – Trennung von Aufgabe (Task) und deren tatsächlicher Ausführung • Task wird durch Interface Runnable beschrieben – Alter Bekannter aus JDK 1.0 • Keine Aussage wann oder wie Tasks ausgeführt wird (Execution) – Schnittstelle nötig für Taskübergabe zur Ausführung (Submission) Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 46 Executor Framework (2) • Neues Interface Executor – Executor Objekte können Tasks zur Ausführung entgegen nehmen • Konkrete Art der Ausführung von Implementierung abhängig • Executor Implementierung bestimmt „Execution Policy“ – Ressourcen Verwendung, Ausführungsreihenfolge, ... – Execution Policy leicht konfigurierbar je nach Hardware Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 47 Executor meets Runnable • Executor Interface public interface Executor { void execute(Runnable command); } • Runnable Interface public interface Runnable { void run(); } Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 48 Neues Code Idiom • Aus alt: new Thread(myRunnable).start() • Mach neu: myExecutor.execute(myRunnable) Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 49 Woher nehmen? (1) • Klasse ThreadPoolExecutor direkt instanziieren – Oder Subklasse ScheduledThreadPoolExecutor • Utility Klasse Executors – Analogon zu Collections Klasse des Collection Frameworks • Executors enthält diverse statische Factory Methoden – Leichtes Executor Erzeugen mit gängigen Voreinstellungen Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 50 Woher nehmen? (2) • newFixedThreadPool(int nThreads) – Feste Größe, ersetzt unerwartet beendete Threads • newCachedThreadPool() – Unbegrenzter Größe, wächst und schrumpft nach Bedarf • newSingleThreadExecutor() – Ein Arbeitsthread, Tasks werden sequentiell abgearbeitet • newScheduledThreadPool(int corePoolSize) – Für verzögerte und periodische Ausführung (Timer Ersatz) Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 51 Stets zu Diensten (1) • Konkrete Executor Implementierung beeinflußt Anwendung – Executor kann z.B. neue Threads erzeugen • Executor stellt Dienst (Service) für Anwendungen zur Verfügung • Verwaltung über eigene Lifecycle Methoden wünschenswert – Dienste können gestartet und gestoppt werden Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 52 Stets zu Diensten (2) • Eigenes Interface ExecutorService – Subinterface von Executor • ExecutorService definiert Lifecycle – Drei Zustände: „Running“, „Shutting Down“ und „Terminated“ • Zustandswechsel durch entsprechende Methoden – shutdown(), shutdownNow(), awaitTermination(), ... • Rückgabetyp der statischen Executors Factory Methoden – implementiert von ThreadPoolExecutor Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 53 Demo Demo „ Concurrency Utilities“ Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 54 Sekunde… • Wenn noch Zeit ist… Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 55 Blick in die Zukunft (1) • Task Abstraktion durch Runnable hat Schwächen – Keine Ergebnisrückgabe (nur Seiteneffekte), keine checked Exceptions • Callable Interface für ergebnisbehaftete Tasks public interface Callable<V> { V call() throws Exception; } • Callable Objekte ausführbar durch ExecutorService – submit() Methoden, geben Future Objekte zurück public interface ExecutorService { // Auszug <T> Future<T> submit(Callable<T> task); } Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 56 Blick in die Zukunft (2) • Future beinhaltet Ergebnis eines asynchronen Aufrufs (Callable) – Ergebnis abfragbar durch Methode get() • Future Interface enthält auch Lebenszyklus eines Tasks – Berechnung kann bei Zeitüberschreitung unterbrochen werden public interface Future<V> { // Auszug V get() throws InterruptedException, ExecutionException; boolean cancel(boolean mayInterruptIfRunning); } • Runnable können in Callable Objekte umgewandelt werden – Util Methode callable() in Klasse Executors – Methode submit() in Interface ExecutorService ist für Runnable überladen – Klasse FutureTask kann Callable Objekte als Runnable wrappen Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 57 Sekunde… • Wenn immer noch Zeit ist… Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 58 Das leidige Dokumentieren (1) • Korrektes Verhalten einer Klasse ist definierbar (dokumentierbar) – Invarianten, Postconditions, Preconditions – Grundvoraussetzung für Aussagen über „Thread-Safety“ • „Thread-Safe“ Klasse impliziert mehrere Dinge – Konkurrierende Aufrufe beeinträchtigen korrektes Verhalten nicht – Synchronisierung unnötig durch Aufrufer • Zwei Dokumentationsebenen (Schnittstelle vs. Implementierung) – Schnittstelle: Ist Locken durch Client möglich?, ... – Implementierung: Welche Locks schützen was?, ... • Alles andere ist raten! Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 59 Das leidige Dokumentieren (2) • Bisher keine definierte Art der Dokumentation – „[...] a class must [...] document in prose [its] level of thread safety [...]“ • Effective Java Item 52 „Document Thread Safety“ – Taxonomie zur Dokumentation von Klassen – Immutable, T-safe, Conditionally T-safe, T-compatible, T-hostile • Concurrency Annotations aus „Java Concurrency in Practice“ – Klassen: @Immtuable, @ThreadSafe, @NotThreadSafe – Felder und Methoden: @GuardedBy(String lock) • Bekanntestes Antibeispiel aus JDK Javadoc – SimpleDateFormat (bis einschließlich Java 1.3) Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 60 Lint Werkzeuge • Werkzeug zur statischen Codeanalyse – Ursprünglich Kommandozeilentool aus der C Welt • Alarmiert über verdächtige Sprachkonstrukte – Aber nicht zwangsläufig falsche Konstrukte • Diverse Tools für Java verfügbar – FindBugs, PMD, Checkstyle, ... – JSR 305 „Annotations for Software Defect Detection“ (Einrichtung 2006) • FindBugs besitzt eigene Kategorie „Multithreaded correctness“ – Double-checked locking, Spin loops, Unreleased locks, ... – Prüft auch Concurrency Annotations („Java Concurrency in Practice“) Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 61 Testen (1) • Concurrent Software ist schwerer testbar als sequentielle – Fehler nicht deterministisch und schwerer reproduzierbar • Testcode ist ebenfalls Concurrent Software – Tests können Fehler im Anwendungscode maskieren • Phänomen bekannt als „Heisenbug“ – „A bug that disappears or alters its behavior when one attempts to probe or isolate it.“ („http://www.jargon.org“) – Tests möglichst frei von Synchronisierung Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 62 Testen (2) • Concurrent Bestandteile einer Anwendung isolieren – Häufig beschränkte Systemteile (Workflows, Pools, Queues, ...) – Oberstes Ziel ist isolierte Testbarkeit • Fehler sind zufällige Ereignisse – Testlaufzeiten erhöhen – Zustandsraum (Ausgangszustände und Eingangsgrößen) variieren • Prozessorzahl der Testplattform berücksichtigen – Zu wenig Threads verhindern Preemption und Thread-Interaktion – Faustregel: Mehr aktive Threads als Prozessoren Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 63 Immutability • Bequeme Möglichkeiten Synchronisierung zu vermeiden – Daten auf einen Thread beschränken (Thread Confinement) – Unveränderliche Objekte verwenden (Immutability) • Immutable Objekte... – können nach Erzeugung nicht verändert werden – geben „this“ Referenz nicht während der Erzeugung weiter – besitzen nur „final“ Felder (Initialization Safety) Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 64 Effectively immutable • Objekte können „Effectively immutable“ sein – zustandsändernde Methoden nach Erzeugung nicht mehr aufrufen – aber Objekt Veröffentlichung muß sicher sein (Safe Publication) • Objektreferenz werden sicher veröffentlicht in... – – – – • static initializer Blöcken volatile Feldern bzw. AtomReference Objekten final Feldern bei Erzeugung von Objekten Lock geschützten Feldern Danach Verwendung als de facto immutable Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 65 Literaturhinweise • Java Concurrency in Practice Sprache: Englisch Broschiert - 403 Seiten - Addison-Wesley Longman Erscheinungsdatum: 25. Mai 2006 ISBN: 0321349601 • Concurrent Programming in Java Sprache: Englisch Broschiert - 411 Seiten - Addison-Wesley Longman Erscheinungsdatum: 31. Dezember 1999 ISBN: 0201310090 • Effective Java. Programming Language Guide. Sprache: Englisch Broschiert - 252 Seiten - Addison Wesely Erscheinungsdatum: 5. Juni 2001 ISBN: 0201310058 Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 66 Links • Java 6 java.util.concurrent API Docs – http://java.sun.com/javase/6/docs/api/java/util/concurrent/package-summary.html • Doug Lea Homepage – http://gee.cs.oswego.edu/dl • JSR 166 Homepage – http://jcp.org/en/jsr/detail?id=166 • The Free Lunch Is Over (Online Artikel) – http://www.gotw.ca/publications/concurrency-ddj.htm • FindBugs Homepage – http://findbugs.sourceforge.net Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 67 If you remember one thing „To summarize, don‘t reinvent the wheel.“ (Effective Java, Item 30: „Know and use the libraries“) Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 68 Vielen Dank für Ihre Aufmerksamkeit ! Orientation in Objects GmbH Weinheimer Str. 68 68309 Mannheim Version: 1.2 www.oio.de [email protected] Papick Garcia Taboada Software Architekt Technologie-Scout Beratung Projekte Training Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 70 Steffen Schluff Im a pogramar Iam a programer I'm a programor I write code Beratung Projekte Training Multithreading im Zeichen von Mehrkernprozessoren © 2007 Orientation in Objects GmbH 71 Noch Fragen… Orientation in Objects GmbH Weinheimer Str. 68 68309 Mannheim Version: 1.2 www.oio.de [email protected] „Orientierung“ in Objekten ) Akademie ) • Schulungen, Coaching, Weiterbildungsberatung, Train & Solve-Programme ) Beratung ) • Methoden, Standards und Tools für die Entwicklung von offenen, unternehmensweiten Systemen Multithreading im Zeichen von Mehrkernprozessoren ) Projekte ) • Schlüsselfertige Realisierung von Software • Unterstützung laufender Projekte • Pilot- und Migrationsprojekte © 2007 Orientation in Objects GmbH 73
