FH-Hof

Threads

Richard Göbel

FH-Hof

Threads - Einführung

Ein Thread ermöglicht die quasi-parallele

Bearbeitung unterschiedlicher Aufgaben.

Threads laufen im Unterschied zu Prozessen im

gleichen virtuellen Speicher ab:

Threads lassen sich effizienter starten

Gemeinsamer Zugriff auf globale Objekte

möglich

Fehler in einem Thread können sich auch auf

andere Threads auswirken

FH-Hof

Threads - Anwendungsbeispiele

Grafische Benutzeroberfläche

Bearbeitung einer größeren Aufgabenstellung

starten

Integration von Animationen

Netzwerkprogrammierung

Server bedient unterschiedliche Clients

gleichzeitig

Client kommuniziert asynchron mit dem Server

und vieles andere mehr

FH-Hof

Optionen zur Erzeugung eines Threads

Definition einer Unterklasse der Klasse Thread Bereitstellung der Methode void run() mit dem

Rumpf des Threads

Thread kann mit Methode void start() gestartet werden

Thread wartet mit Methode void sleep(int msek)

Thread soll selbständig die Arbeit beenden (z. B. als Ergebnis eines externen Signals)

Implementierung des Interface Runnable Bereitstellung der Methode void run()

Erzeugung eines Threads mit dem Konstruktor Thread(Runnable target)

FH-Hof

Programmbeispiel - News Ticker Teil 1

JLabel display = new JLabel();

boolean tickerRunning = false;

class NewsTicker extends Thread {

private String news = ". . .";

private int l = 16;

public void run() {

int s;

while (tickerRunning) {

for (int i = -l; i <= news.length()-l; i++) {

if (i < 0) s = 0; else s = i;

display.setText(news.substring(s,i+l));

try{sleep(200);}

catch (InterruptedException e) {return;}}}}}

FH-Hof

Programmbeispiel - News Ticker Teil 2

Thread startenThread ticker = new NewsTicker();

tickerRunning = true;

ticker.start();

Thread anhalten

tickerRunning = false;

FH-Hof

Zustand eines Threads

Thread wurde erzeugt aber noch nicht gestartet

Thread wurde gestartet und läuft (runnable)

Thread wurde gestartet und wartet (not

runnable)

Methode „run“ des Thread wurde beendet

(dead)

FH-Hof

Interface Runnable

Implementierung des Interface Runnable durch

eine beliebige Klasse:class MyClass implements Runnable {

. . .

public void run() {

. . .

}

}

Starten des ThreadMyClass c = new MyClass( . . . );

Thread aThread = new Thread(c);

aThread.start();

FH-Hof

Problem: Synchronisation von Threads

Thread A Thread BPuffer für

Zeichenkette

ein Test

Dies istschreibt

liestDies ist

schreibt Dies ist

FH-Hof

Synchronisation mit einem Monitor - Optionen

Deklaration einer Methode mit dem

Schlüsselwort synchronized

Deklaration eines Blocks mit dem Konstrukt

synchronized ( expression ) block

Die so markierten Anweisungen dürfen nicht

gleichzeitig :

auf das zugehörige Objekt für die Methode oder

auf das Ergebnisobjekt des Ausdrucks

angewendet werden

Der interne Scheduler blockiert bei Bedarf die

Ausführung von Anweisungen für ein Objekt

FH-Hof

Verwendung des Konstrukts „synchronized“

Thread A Thread BStringBuffer b

synchronized (b) { . . . b.append( . . . ) . . . b.append( . . .) }

String s; . . .synchronized (b) { . . . s = new String(b); . . .} . . .

FH-Hof

Manuelle Synchronisierung

Thread A Thread BObject o

synchronized (o) { . . . o.notify() . . .}

. . .synchronized (o) { . . . o.wait(); . . .} . . .

FH-Hof

Probleme bei der Verwendung eines Monitors

Deadlock (Verklemmung): Threads greifen

wechselweise auf benötigte Ressourcen zu.

Starvation: Ein Thread wird aufgrund der

Arbeitsweise anderer Threads nie aufgerufen.

Lösung: Realisierung einer

Kommunikationsstruktur, die aus den

Rahmenbedingungen der Anwendung diese

Probleme ausschließt