Threads

Themen
Threads in Java
Stefan Szalowski
Programmierung II
Multitasking/Threads
Einleitung
●
Begriff „Multitasking“:
●
●
Paralleles (quasi gleichzeitiges) Ausführen mehrerer
Prozesse
Aufteilung der CPU-Zeit für mehrere Prozesse
–
●
●
Vewendung eines Schedulers
Jeder Prozeß erhält eigenen Speicherbereich
Begriff „Thread“:
●
●
Aufteilung eines Prozesses in mehrere gleichzeitig
ablaufende Programmteile, die Threads
Unterschiedliche Threads laufen asynchron
–
–
Stefan Szalowski
Keine Voraussage, wann ein Thread unterbrochen wird
Möglichkeit der Synchronistaion in Java gegeben --> später
Programmierung II
Multitasking/Threads
Einleitung
●
Nutzung von Threads in Java
●
Gleichzeitiges Ausführen verschiedener Programmteile
–
–
–
●
Vorstellung, dies alles würde sequentiell ablaufen
–
–
–
Stefan Szalowski
Arbeiten mit dem Programm durch den Anwender
Speichern von Daten (im Hintergrund)
Berechnung von Programm-Parametern (im Hintergrund)
Der Anwender veranlasst das Programm zur Datenspeicherung
Problematisch bei großen Datenmengen
● Arbeit mit dem Programm blockiert, bis vollständig
gespeichert wurde
Noch Problamtischer:
● GUI-Programmierung
● Beispiel Mediaplayer
Programmierung II
Multitasking/Threads
Threads in Java
●
Eigene Thread-Klassen
–
–
Ableitung nach Klasse
Implementierung des Interface
:
:
java.lang.Thread
java.lang.Runnable
// Eigenene Threads
// ... entweder ...
public class Producer extends Thread {
// Producer erbt von Thread
}
// ... oder ...
public class Consumer implements Runnable { // Consumer implementiert
// Interface Runnable
}
Stefan Szalowski
Programmierung II
Multitasking/Threads
Threads in Java
●
Eigene Thread-Klassen
–
–
Stefan Szalowski
java.lang.Thread implementiert java.lang.Runnable
● Siehe „Javadocs“
Was bedeutet das für uns?
Programmierung II
Multitasking/Threads
Threads in Java
●
Eigene Thread-Klassen
–
–
java.lang.Thread implementiert java.lang.Runnable
● Siehe „Javadocs“
Was bedeutet das für uns?
● Eigene Thread-Klassen müssen die run()-Methode des
Interface java.lang.Runnable implementieren
public class Producer extends Thread {
}
public void run() {
// Daten erzeugen
}
public class Consumer implements Runnable {
}
public void run() {
// Daten verarbeiten
}
Stefan Szalowski
Programmierung II
Multitasking/Threads
Threads in Java
●
Eigene Thread-Klassen
–
Weshalb existieren zwei Möglichkeiten, Thread-Funktionalitäten
zu nutzen?
●
Eigene Klasse implementiert java.lang.Runnable
–
–
●
Eigene Klasse erbt von java.lang.Thread:
–
–
Stefan Szalowski
Wenn sich eigene Thread-Funktionalitäten auf die run()Methode beschränken
● Schnell mal die nächstgrößere Primzahl berechnen :o)
● Speichern im Hintergrund
In den meisten Fällen sollte Runnable implementiert werden
Wenn eigene Thread-spezifische Funktionalitäten
überschrieben werden sollen
● Eigene Aufgaben beim Starten des Threads
● Eigene Reaktionen auf Thread-Unterbrechungen
Besser Runnable implementieren!!!
Programmierung II
Multitasking/Threads
Threads in Java
●
Starten eines Threads
●
start()-Methode
–
–
Veranlasst die JVM die run()-Methode aufzurufen
Darf auf einem Thread-Objekt nur einmal aufgerufen werden
● Sonst wird IllegalThreadStateException geworfen
public class MeinProgramm {
private static Thread producer = null;
public static void main(String[] args) {
producer = new Producer();
producer.start();
// starten des Threads
nochmalStarten();
// Exception tritt auf
}
}
public static void nochmalStarten() {
producer.start();
}
Stefan Szalowski
Programmierung II
// löst Exception aus
Multitasking/Threads
Threads in Java
●
Anhalten eines Threads
●
stop()-Methode? - Nein!!!
–
●
Alternative Lösung aus Java-Festlegung:
–
●
„deprecated“ deklariert, da Gefahr eines „deadlock“ --> siehe
„Javadoc“
Ein Thread wird beendet, wenn die Ausführung seiner run()Methode endet
Unterbrechen/Aufwecken eines Threads
●
●
interrupt()-Methode
sleep()-Methoden
–
●
wait()-Methoden
–
–
●
Stefan Szalowski
Anhalten eines Threads für festgelegte Zeit
Anhalten eines Threads auch auf unbestimmte Zeit ...
... bis zum „Aufwecken“
notify()/notifyAll()-Methoden zum „erwecken“
Programmierung II
Multitasking/Threads
Threads in Java
●
Beispiel-Anwendung (aus dem Java-Tutorial):
●
Problemstellung:
–
–
–
Ein „Producer“-Thread erzeugt fortlaufend Daten ...
... und schreibt diese Daten in ein Depot mit begrenzter
Kapazität
Ein „Consumer“-Thread liest fortlaufend Daten aus dem Depot
ProducerThread
Stefan Szalowski
Zugriff
schreibend
Depot
Programmierung II
Zugriff
lesend
ConsumerThread
Multitasking/Threads
Threads in Java
●
Beispiel-Anwendung (aus dem Java-Tutorial):
●
Haupt-Programm
public class ThreadDemoProgramm {
public static void main(String[] args) {
Depot depot = new Depot();
Producer prod = new Producer(depot);
Consumer cons = new Consumer(depot);
}
}
// Erzeugen eines Threads, der die run-Methode() der Klasse
// Consumer ausführen soll
Thread consThread = new Thread(cons);
try {
consThread.start(); // Starten des Consumer-Threads
prod.start();
// Starten des Producer-Threads
} catch (Exception exc) {
exc.printStackTrace();
}
Stefan Szalowski
Programmierung II
Multitasking/Threads
Threads in Java
●
Beispiel-Anwendung (aus dem Java-Tutorial):
●
Producer-Thread
public class Producer extends Thread {
private Depot myDepot = null;
}
public Producer(Depot d) {
// Parameter gibt Depot an
this.myDepot = d;
// in das geschrieben werden soll
}
public void run() {
int i=0;
while (true) {
i++;
try {
myDepot.setContent(i);
// schreiben der Daten
} catch (InterruptedException iexc) {
iexc.printStackTrace();
}
}
}
Stefan Szalowski
Programmierung II
Multitasking/Threads
Threads in Java
●
Beispiel-Anwendung (aus dem Java-Tutorial):
●
Consumer-Thread
public class Consumer implements Runnable {
private Depot myDepot = null;
}
public Consumer(Depot d) {
// Parameter gibtDepot an, aus
this.myDepot = d;
// dem gelesen werden soll
}
public void run() {
int data = -1;
while(true) {
try {
data = myDepot.getContent();
// lesen der Daten
} catch (InterruptedException iexc) {
iexc.printStackTrace();
}
System.out.println(data);
// Ausgabe
}
}
Stefan Szalowski
Programmierung II
Multitasking/Threads
Threads in Java
●
Beispiel-Anwendung (aus dem Java-Tutorial):
●
Schwierigkeiten:
–
–
–
–
●
Threads laufen gleichzeitig
–
–
●
Stefan Szalowski
Der Producer darf nur in das Depot schreiben, wenn dieses
nicht voll ist
Der Producer darf keine noch nicht gelesenen Daten
überschreiben
Der Consumer darf nur aus dem Depot lesen, wenn dieses nicht
leer ist
Der Consumer darf keine Daten mehrfach lesen
Keine Vorhersage möglich, wann welcher Thread arbeitet
Threads können jederzeit unterbrochen werden
● Auch in der Abarbeitung einer Methode
Synchronisation erforderlich!!!
Programmierung II
Multitasking/Threads
Synchronisation/Sychronisierung
●
Mittels synchronized können Threads synchronisiert werden
●
d.h. die (quasi) gleichzeitige Ausführung einer Methode durch
verschiedene Threads wird unterbunden
public class Depot {
public synchronized int getContent()
throws InterruptedException {
// etwas sinnvolles
}
public synchronized void setContent(int content)
throws InterruptedException {
// etwas sinnvolles
}
Stefan Szalowski
Programmierung II
Multitasking/Threads
Synchronisation/Sychronisierung
●
Beipiel-Programm
Stefan Szalowski
Programmierung II
Multitasking/Threads