Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Java-Praktikum SonstigesDietrich BolesSeite 1 Threadnocchio Dietrich Boles Nachdenken in Aurich 2009 Threadnocchio Spielerisches Erlernen der parallelen.

Ähnliche Präsentationen


Präsentation zum Thema: "Java-Praktikum SonstigesDietrich BolesSeite 1 Threadnocchio Dietrich Boles Nachdenken in Aurich 2009 Threadnocchio Spielerisches Erlernen der parallelen."—  Präsentation transkript:

1 Java-Praktikum SonstigesDietrich BolesSeite 1 Threadnocchio Dietrich Boles Nachdenken in Aurich 2009 Threadnocchio Spielerisches Erlernen der parallelen Programmierung mit Java-Threads Dietrich Boles

2 Java-Praktikum SonstigesDietrich BolesSeite 2 Threadnocchio Dietrich Boles Gliederung Java-Threads vor Java 5 Threads Scheduling syncronized wait-notify Java-Threads seit Java 5 Sperren Atomare Variablen Queues Nützliche Synchronisationsklassen Thread-Pools Einführung in das Arbeiten mit Threadnocchio Praktisches Arbeiten mit Threadnocchio

3 Java-Praktikum SonstigesDietrich BolesSeite 3 Threadnocchio Dietrich Boles Java-Threads Klasse java.lang.Thread public class ThreadKlasse extends Thread { private String str; public ThreadKlasse(String s) { this.str = s; } public void run() { while (true) System.out.println(this.str); } public static void main(String[] args) { ThreadKlasse hallo = new ThreadKlasse("hallo"); ThreadKlasse dibo = new ThreadKlasse("dibo"); hallo.start(); dibo.start(); } } ( 1-threads-startrek)

4 Java-Praktikum SonstigesDietrich BolesSeite 4 Threadnocchio Dietrich Boles Thread-Zustände erzeugtbereit rechnend beendet blockiert start() Ende von run zuordnen verdrängen, yield() blockieren (synchronized, sleep, join, wait, EA) deblockieren (synchronized-Ende, sleep-Ende, Thread-Ende, notify, EA-Ende, interrupt)

5 Java-Praktikum SonstigesDietrich BolesSeite 5 Threadnocchio Dietrich Boles Scheduling static int activeCount() static int enumerate(Thread[] tarray) static Thread currentThread() Thread.State getState() // NEW, TERMINATED, WAITING, … void setPriority(int priority) // wenig sinnvoll int MIN_PRIORITY, int MAX_PRIORITY, int NORM_PRIORITY static void yield() // in Zustand bereit static void sleep(long milliSekunden) // blockieren void join() // auf Ende warten void interrupt() // sleep, join unterbrechen void setDaemon(boolean on) // Garbage-Collector

6 Java-Praktikum SonstigesDietrich BolesSeite 6 Threadnocchio Dietrich Boles Kommunikation Kommunikation = Datenaustausch über gemeinsame Variablen bzw. Objekte möglich, da sich Threads einen gemeinsamen Adressraum teilen Probleme bei der Nutzung gemeinsamer Variablen Nicht-determinierte Ergebnisse durch Races (Wettrennen) Schreib/Schreibkonflikte Schreib/Lesekonflikte Kritische Abschnitte Lösung: Synchronisation = Ordnung der Abfolge bestimmter Aktivitäten mehrerer Threads Synchronisationsarten: mehrseitige Synchronisation einseitige Synchronisation

7 Java-Praktikum SonstigesDietrich BolesSeite 7 Threadnocchio Dietrich Boles synchronized jedes Objekt besitzt Sperre (Lock) Sperren können implizit gesetzt bzw. freigegeben werden synchronized-Anweisung: synchronized ( ) // Sperr-Objekt // Kritischer Abschnitt synchronized-Methoden synchronized void m() { /* krit Abschnitt */ } entspricht: void m() { synchronized (this) { /* krit Abschnitt */ } } 2-mssync-elefanten

8 Java-Praktikum SonstigesDietrich BolesSeite 8 Threadnocchio Dietrich Boles wait-notify (1) Problem: Bestimmte Anweisungen sollen nur dann ausgeführt werden, wenn anwendungsabhängige Bedingungen erfüllt sind; ansonsten warten (und zwar nicht aktiv!) public class Object { public final void wait() // passives Warten public final void notify() // wecken (eines Threads) public final void notifyAll() // wecken aller }

9 Java-Praktikum SonstigesDietrich BolesSeite 9 Threadnocchio Dietrich Boles wait-notify (2) synchronized (obj) { while (!bedingung) obj.wait(); } Voraussetzung: Lock von obj ist gesetzt ( synchronized) Aufrufender Thread wird blockiert Lock von obj wird frei gegeben synchronized (obj) { bedingung erfüllen; obj.notify(); } Voraussetzung: Lock von obj ist gesetzt ( synchronized) Irgendein Thread T1, der auf obj wartet, wird in den Zustand bereit versetzt ( notifyAll alle) T1 muss erst wieder Lock setzen, bevor er fortfahren kann 3-essync-baby

10 Java-Praktikum SonstigesDietrich BolesSeite 10 Threadnocchio Dietrich Boles Semaphore (1) Java: synchronized-Anweisung Nachteile: Block-gebunden Kein Hand-over-Locking möglich Thread-gebunden Exklusiv Lösung: Semaphore // Thread 1 // Thread 2 sem.p(); // kritischer Abschnitt sem.v();

11 Java-Praktikum SonstigesDietrich BolesSeite 11 Threadnocchio Dietrich Boles Semaphore (2) public class Semaphor { private int freiePlaetze; public Semaphor(int maximalFreiePlaetze) { if (maximalFreiePlaetze < 0) this.freiePlaetze = 0; else this.freiePlaetze = maximalFreiePlaetze; } public synchronized void p() { while (this.freiePlaetze == 0) { try { this.wait(); } catch (InterruptedException exc) {} } this.freiePlaetze--; } public synchronized void v() { this.freiePlaetze++; this.notify(); }

12 Java-Praktikum SonstigesDietrich BolesSeite 12 Threadnocchio Dietrich Boles Semaphore (3) package java.util.concurrent; class Semaphore { // seit Java 5 public Semaphore(int permits) public Semaphore(int permits, boolean fair) public void acquire() throws InterruptedException public void acquireUninterruptibly() // p public boolean tryAcquire() public void release() // v... } 4-semaphore-elefanten

13 Java-Praktikum SonstigesDietrich BolesSeite 13 Threadnocchio Dietrich Boles Locks(1) synchronized : implizite Sperren Locks: explizite Sperren (seit Java 5) public interface Lock { public void lock(); public void unlock(); public Condition newCondition() } public interface Condition { public void await() throws InterruptedException public void signal() public void signalAll() } public class ReentrantLock implements Lock {... }

14 Java-Praktikum SonstigesDietrich BolesSeite 14 Threadnocchio Dietrich Boles Locks(2) Lock sperre = new ReentrantLock(); Condition bedingung = sperre.newCondition(); sperre.lock(); try {... bedingung.await(); // auf Erfülltsein warten } finally { sperre.unlock(); } sperre.lock(); try {... bedingung.signal(); // Erfülltsein signalisieren } finally { sperre.unlock(); } 5-locks-baby

15 Java-Praktikum SonstigesDietrich BolesSeite 15 Threadnocchio Dietrich Boles ReadWriteLocks ReadWriteLocks: Lösung für Reader-Writer-Problem 2 Locks: ReadLock: mehrere Threads WriteLock: exklusive Sperre public interface ReadWriteLock { public Lock readLock() public Lock writeLock() } public class ReentrantReadWriteLock implements ReadWriteLock 6-rwlocks-elefanten

16 Java-Praktikum SonstigesDietrich BolesSeite 16 Threadnocchio Dietrich Boles Atomare Variablen (1) Klassen für atomare Variablen der Standarddatentypen keine Sperren notwendig class Konto { int kontostand1 = 0; AtomicInteger kontostand2 = new AtomicInteger(0); synchronized int einzahlen1(int betrag) { return kontostand1 = kontostand1 + betrag; } int einzahlen2(int betrag) { return this.kontostand.addAndGet(betrag); }

17 Java-Praktikum SonstigesDietrich BolesSeite 17 Threadnocchio Dietrich Boles Atomare Variablen (2) package java.util.concurrent.atomic; public class AtomicInteger extends java.lang.Number { public AtomicInteger(int initialValue) public final void set(int newValue) public final int get() public final boolean compareAndSet(int exp, int update) public final int addAndGet(int delta) public final int getAndIncrement() public final int getAndDecrement() public final int getAndAdd(int delta)... }

18 Java-Praktikum SonstigesDietrich BolesSeite 18 Threadnocchio Dietrich Boles Queues Interfaces Queue (add, element, remove, …) BlockingQueue (put, poll, …) Deque (addFirst, addLast, …) BlockingDeque (offerFirst, offerLast, …) Klassen ArrayBlockingQueue (begrenzt) LinkedBlockingQueue (unbegrenzt) LinkedBlockingDeque (unbegrenzt) SynchronousQueue (Übergabe on-the-fly) PriorityBlockingQueue (Lieferung gemäß Prioritäten) DelayQueue (Objekte bestimmen Verweildauer) … 7-queues-baby

19 Java-Praktikum SonstigesDietrich BolesSeite 19 Threadnocchio Dietrich Boles Exchanger Welchselseitiger Austausch von Objekten zwischen Threads package java.util.concurrent; public class Exchanger { public Exchanger() public V exchange(V data) throws InterruptedException } 8-exchanger-baby (ohne Lösung)

20 Java-Praktikum SonstigesDietrich BolesSeite 20 Threadnocchio Dietrich Boles CountDownLatch Realisierung von Count-Downs package java.util.concurrent; public class CountDownLatch { public CountDownLatch(int initCount) public void await() throws InterruptedException public void countDown()... } 9-countdown-animals

21 Java-Praktikum SonstigesDietrich BolesSeite 21 Threadnocchio Dietrich Boles CyclicBarrier Realisierung von Sammelpunkten package java.util.concurrent; class CyclicBarrier { public CyclicBarrier(int anzahl) public int await() throws InterruptedException, BrokenBarrierException... } 10-barriers-animals

22 Java-Praktikum SonstigesDietrich BolesSeite 22 Threadnocchio Dietrich Boles FutureTask Threads, die Ergebnisse liefern public interface Callable { public V call() throws Exception; } public class FutureTask implements Runnable { public FutureTask(Callable callable) public V get() throws InterruptedException, ExecutionException //... }

23 Java-Praktikum SonstigesDietrich BolesSeite 23 Threadnocchio Dietrich Boles Thread-Pooling (1) Threads auf Vorrat class ThreadPoolExecutor implements ExecutorService { public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) public void execute(Runnable command)... } public class Executors { public static ExecutorService newCachedThreadPool() public static ExecutorService newFixedThreadPool(int maxThreads) //... }

24 Java-Praktikum SonstigesDietrich BolesSeite 24 Threadnocchio Dietrich Boles Thread-Pooling (2) int ANZAHL_AUFTRAEGE = 5; int ANZAHL_GLEICHZ_THREADS = 2; ExecutorService dienstleister = Executors.newFixedThreadPool(ANZAHL_GLEICHZ_THREADS); for (int i = 0; i < ANZAHL_AUFTRAEGE; i++) { dienstleister.execute( ); } dienstleister.shutdown();

25 Java-Praktikum SonstigesDietrich BolesSeite 25 Threadnocchio Dietrich Boles Arbeiten mit Threadnocchio

26 Java-Praktikum SonstigesDietrich BolesSeite 26 Threadnocchio Dietrich Boles Aufgaben 1.Passt das Stück Exchanger so an, dass Kauffrauen und Mütter an der Kasse Essen gegen Geld tauschen! 2.Versucht einmal, die Klasse Exchanger mit den Java-1.4- Standardmechanismen selbst zu implementieren!


Herunterladen ppt "Java-Praktikum SonstigesDietrich BolesSeite 1 Threadnocchio Dietrich Boles Nachdenken in Aurich 2009 Threadnocchio Spielerisches Erlernen der parallelen."

Ähnliche Präsentationen


Google-Anzeigen