Nebenläufige Anwendungen in Java (J2SE, Rich Client, J2EE)

Transkript

1 CNAM Wintersemester 2014 / 2015 Nebenläufige Anwendungen in Java (J2SE, Rich Client, J2EE) Im Rahmen von: Betriebssysteme und nebenläufige Anwendungen

2 Agenda Nebenläufigkeit in Java Anwendungen Basisfunktionen in allen Java Objekten Threads Thread Pools Fork/Join Monitor Semaphores Besonderheiten in Container Managed und Plug-In Umgebungen WorkManager Job APIs

3 Java unterstützt Nebenläufigkeit seit der ersten Version Basisfunktionen in Object Java wurde als Sprache für nebenläufige Anwendungen konzipiert Jedes Java Objekt erbt von java.lang.object notifyall wait notify Jedes Objekt erhält durch die Objektspezialisierung automatisch die Methoden wait, notify und notifyall Dadurch hat jedes Objekt eine einfache start/stop- Logik im Bauch java.lang. Object Thread Programmierung - Basics Threads werden durch Vererbung von Thread oder durch Implementierung des Runnable Interfaces angelegt Objekte, welche Runnable implementieren müssen über eine Instance von Thread gestartet werden Die Laufzeitlogik wird durch Überschreibung der run Methode implementiert Callable (ab 1.5) ermöglicht Rückgabewerte Über die statische Methode sleep kann ein Thread schlafen gelegt werden java.lang. Runnable run java.lang. Thread start sleep

4 Einfache Threads public class SetupThreads public class Runner implements Runnable public void run() //do something useful public class MyFirstThread extends Thread public void run() //do something useful public SetupThreads() new MyFirstThread().start(); new Thread(new Runner()).start(); public static void main(string[] args) new SetupThreads();

5 Threads mit Schlafzeit public class SetupThreadsTwo public static final int SLEEP_TIME = 200; public class MySecondThread extends Thread public void run() try Thread.sleep(SetupThreadsTwo.SLEEP_TIME); catch (InterruptedException e) e.printstacktrace(); public SetupThreadsTwo(int count) MySecondThread thread [] = new MySecondThread[count]; for (int i=0; i < thread.length;i++) thread[i] = new MySecondThread(); thread[i].start(); for (MySecondThread handle : thread) try handle.join(); catch (InterruptedException e) e.printstacktrace();

6 Werten wir das letzte Beispiel mit Zahlen aus. public static void main(string[] args) for(int i=1000;i<=10000; i=i+1000) new SetupThreadsTwo(i); long timetaken = System.currentTimeMillis() - start; long offsettoruntime = timetaken - SetupThreadsTwo.SLEEP_TIME; double setuptimeperthread = (double)offsettoruntime/(double) count; System.out.println("Result: Number threads "+count+" Time taken " + timetaken + " ms Offset to sleep time "+offsettoruntime+" ms Setup time per Thread "+setuptimeperthread+" ms"); Gebrauchte Zeit = Endzeit Startzeit Offset Zeit = Gebrauchte Zeit Wartezeit Thread Thread Management Zeit = Offset Zeit Anzahl Threads Result: Number threads 1000 Time taken 267 ms Offset to sleep time 67 ms Setup time per Thread ms Result: Number threads 2000 Time taken 315 ms Offset to sleep time 115 ms Setup time per Thread ms Result: Number threads 3000 Time taken 374 ms Offset to sleep time 174 ms Setup time per Thread ms Result: Number threads 4000 Time taken 447 ms Offset to sleep time 247 ms Setup time per Thread ms Result: Number threads 5000 Time taken 502 ms Offset to sleep time 302 ms Setup time per Thread ms Result: Number threads 6000 Time taken 567 ms Offset to sleep time 367 ms Setup time per Thread ms Result: Number threads 7000 Time taken 638 ms Offset to sleep time 438 ms Setup time per Thread ms Result: Number threads 8000 Time taken 702 ms Offset to sleep time 502 ms Setup time per Thread ms Result: Number threads 9000 Time taken 779 ms Offset to sleep time 579 ms Setup time per Thread ms Result: Number threads Time taken 852 ms Offset to sleep time 652 ms Setup time per Thread ms

7 Was bringen Threads. Beispiel: Zerlegen von 1000 Zahlen Lauf/ Threadanzahl Summe Durchschnitt 19,2 Sek 8,5 Sek 6,3 Sek 3,4 Sek 3,2 Sek

8 Pooling von Threads Basisfunktionen von Thread Pools Thread Pools sind fester Bestandteil der Concurency API in Java Pools können fix, dynamisch oder scheduled sein Wurde wie viele Erweiterungen über den JSR Prozess in Java aufgenommen (JSR 166) Seit Java 5 im Framework verankert Ältere Java Versionen benötigen externe Frameworks new Cached Thread Pool new Fixed Thread Pool java.util. concurrent.executors new Scheduled Thread Pool Das Framework enthält neben den allgemeinen Vorteilen von Thread Pools auch diese Vorteile: Entlastung des Entwicklers (Thread Handling ist im Framework gekapselt) Damit ebenfalls eine best-practise Implementierung Man spart sich den manuellen Umgang mit notify, wait, synchronize etc. java.util. concurren. Executor Service shutdown execute

9 Verwendung von Thread Pools public class SetupThreadPool public class Runner implements Runnable public void run() try Thread.sleep(200); catch (InterruptedException e) e.printstacktrace(); public void startallthreads(int poolsize) long start = System.currentTimeMillis(); ExecutorService executor = Executors.newFixedThreadPool(poolsize); for (int i = 0; i < 20; i++) executor.execute(new Runner()); executor.shutdown(); while (!executor.isterminated()) System.out.println("Pool: "+poolsize+" take: "+ (System.currentTimeMillis()-start)); public static void main(string[] args) for(int i=1;i<=20;i++) new SetupThreadPool().startAllThreads(i); Pool: 1 take: 4005 Pool: 2 take: 2001 Pool: 3 take: 1400 Pool: 4 take: 1000 Pool: 5 take: 800 Pool: 6 take: 800 Pool: 7 take: 600 Pool: 8 take: 600 Pool: 9 take: 600 Pool: 10 take: 401 Pool: 11 take: 400 Pool: 12 take: 401 Pool: 13 take: 401 Pool: 14 take: 400 Pool: 15 take: 401 Pool: 16 take: 400 Pool: 17 take: 400 Pool: 18 take: 400 Pool: 19 take: 400 Pool: 20 take: 203

10 Weitere Implementierungen in Java 1.5 Barrieren class WorkerRun implements Runnable private CyclicBarrier barrier; Barrieren ermöglichen das Warten auf eine Gruppe von Threads Üblicherweise wird der CyclicBarrier verwendet Der CyclicBarrier gibt eine Anzahl an Threads an, welche durchlaufen werden müssen Nach Abschluß wird ein weiterer Thread angestoßen public WorkerRun(CyclicBarrier barrier) this.barrier = barrier; public void run() try barrier.await(); catch (Exception e) Queue Über Queues können ThreadSafe Queues generiert werden Dies bietet sich besonders für Consumer Provider Anwendungen an Beispiel: Eine BlockingQueue aufbauen und mit take und put aus mehreren Threads arbeiten public void start() CyclicBarrier barrier = new CyclicBarrier (3, new AbschlussRun()); for (int i = 0; i < 3; i++) new Thread( new WorkerRun(barrier) ).start();

11 Fork Join Ab Java 1.7 sind Funktionen ForkJoin neu im Java SDK Die Grundidee ist die work-stealing Prinzip Im Gegensatz zum ThreadPool warten sie nicht per join auf das Ergebnis von allen Workern. Die Teil der Arbeit wird auf die freien Arbeitsprozesse verteilt. In der Java Doku wird angegeben, dass damit die Systemressourcen besser aufgeteilt werden java.util. concurrent.recursive Task java.util. concurrent.forkjoin Pool java.util. concurrent.forkjoin Task java.util. concurrent.recursive Action Im Code wird ein ForkJoinPool aufgebaut Die Arbeit und der fork() wird durch eine RecursiveAction oder RecursiveTask durchgeführt (Action hat kein Return)

12 Arbeiten mit Monitor Es ist möglich kritische Bereiche in Java anzulegen Einzelne Abschnitte können mit synchronized gesichert werden Ebenfalls kann das Schlüsselwort auf ganze Methoden angewendet werden Durch den wait / notify Mechanismus können andere Threads über den nun freien kritischen Bereich benachrichtigt werden public class Runner implements Runnable int criticalvariable; public void run() synchronized (this) criticalvariable ++; Ebenfalls kann das Schlüsselwort volatile auf Variablen angewendet werden Diese Variablen haben das Prinzip lesen vor schreiben und erst den Cache leeren criticalarea(2); //non critical code public synchronized void criticalarea(int v) CriticalVariable += v;

13 Sperren Ab Java 1.5 sind ebenfalls Lock Interfaces und Lock Klassen in der Implementierung Mit diesen Implementierungen wird das sperren und entsperren mittels Bedingungen ermöglicht Im Gegensatz zum klassischen Monitor gibt es zahlreiche Vorteile Funktioniert trylock nicht, blockiert der Code nicht Locking kann an einzelne Bedingungen geknüpft werden Lock / Unlock ist Methodenübergreifend Schreib- und Leselock Lock sperre = new ReentrantLock(); sperre.trylock(); //something critical sperre.unlock(); ReadWriteLock readwritelock = new ReentrantReadWriteLock(); readwritelock.readlock().lock(); readwritelock.readlock().unlock(); readwritelock.writelock().lock(); readwritelock.writelock().unlock();

14 Atomic Implementierungen Ab Java 1.5 sind verschiedene atomare Objekte in der JVM vorhanden Die Implementierungen betreffen Repräsentationen von primitiven Datentypen wie z.b. int, long, boolean Arrays HashMaps FieldUpdater (als wrapper) Die atomaten Klassen bieten einen Angebot an nicht unterbrechbaren Funktionen zur Verfügung. Dazu gehört zum Beispiel das lesen und addieren, erhöhen und lesen, lesen und erhöhen public class AtomicSample private AtomicInteger zaehler = new AtomicInteger(0); public void hochzaehlen() zaehler.incrementandget(); public int getzaehler() return zaehler.get();

15 Alternative zum Monitor Semaphoren Mit der Concurrency API haben auch die Semaphoren Einzug in Java gehalten. Sie bieten eine gute Alternative zum Monitor (synchronized) Semaphoren sollten static definiert werden, um übergreifend verwendet zu werden Mit acquire und release können Semaphoren gebucht werden. Bei Acquire blockt der Code bis die semaphore wieder frei ist Alternativ gibt es den tryacquire Aufruf, der ein boolean zurückliefert import java.util.concurrent.semaphore; public class SemaHandling extends Thread private static Semaphore semaphore = new Semaphore(1); public void run() try semaphore.acquire(); //Alternative: semaphore.tryacquire(); catch (InterruptedException e) e.printstacktrace(); //Kritischer Code semaphore.release(); public static void main(string[] args) new SemaHandling().start();

16 Nebenläufigkeit in J2EE und Eclipse Apps Auf dem Application Server In J2EE Umgebungen sollten alle Threads vom Container verwaltet werden und ein Wildwuchs an Threads muss vermieden werden Bei hosted AppServern und Cloud-Lösungen wird dieser Ansatz um so wichtiger. Der Server benötigt die volle Kontrolle über alle Arbeitsprozesse Aktuell steigt in der Industrie allerdings auch der Bedarf nach Konsolidierung Ebenfalls stieg der Wunsch nach Batch Processing in den letzten Jahren deutlich an Interessante Alternativen bieten ebenfalls die Async Schnittstellen von J2EE Komponenten wie Services, Servlets und Beans JSR 237 Timer & WorkManager wurde zurückgezogen und mit JSR 236 zusammengeführt JSR 236 Concurrency Utilities for Java EE Teil von JEE 7 Im Rich Client Eclipse hat sich in den letzten Jahren als bevorzugte Komponente für viele Rich Client Lösungen durchgesetzt Leider verwenden viele Anwendungen Threads direkt und einige Plug-Ins starten nach dem Laden bis zu 20 Threads auf Vorrat Gerade für nebenläufige Arbeitsvorgänge bietet Eclipse neben den Unit of Work, Jobs, Progress Monitor noch viele andere Build-in Funktionen Die direkte Verwendung von Threads umgeht dabei diese Standardfunktionen und bestpractise Patterns

17 Setup von WorkManager WorkManager werden im AppServer (z.b. IBM WebSphere) bekanntgemacht. Jede Anwendung referenziert die entsprechenden Einträge in der Deployment Description <resource-ref> <res-ref-name>wm/utlul</res-ref-name> <res-type>commonj.work.workmanager</res-type> <res-auth>container</res-auth> <res-sharing-scope>shareable</res-sharing-scope> </resource-ref>

18 Beispiele CommonJ WorkManager public class MyWorker implements Work public void run () //logic InitialContext ctx = new InitialContext(); WorkManager wm = (WorkManager) ctx.lookup( java:comp/env/wm/meinwm ); MyWorker work1 = new MyWorker(); WorkItem item1; Item1=wm.schedule(work1 ); Collection col1 = new ArrayList(); col1.add(item1); wm.waitforall(col1, WorkManager.INDEFINITE); Collection finished = wm.waitforany(col1, 1000);

19 Beispiel für den Rich Client Eclipse Jobs Job job = new Job("My protected IStatus run(iprogressmonitor monitor) // do something long running //... // If you want to update the UI sync.asyncexec(new public void run() // do something in the user interface // e.g. set a text field ); return Status.OK_STATUS; ; // Start the Job job.schedule();