2. Thread-Programmierung


Thread Funktionalität als Sprachkonstrukte oder externe Bibliotheken

Abbildung 1: Threads innerhalb von Prozessen

\begin{picture}(142.00,145.00)
% put(21.00,22.00)\{ framebox(121.00,123.00)[cc]\...
...(118.00,126.00){\circle*{5.20}}
\put(30.00,140.00){\circle*{5.20}}
\end{picture}

Abbildung 1a: Thread Zustände

Thread States

Java-Implementierung von Threads, enthalten in dem Java-Package java.lang:

  1. der Klasse Thread und dem Interface Runnable,
  2. dem Java-Sprachkonstrukt synchronized und
  3. den Methoden wait(), notify() der Basisklasse Object.

2.1 Thread Erzeugung

Erzeugung von Threads:
ein Objekt einer geeigneten Klasse erzeugen,
Aufruf einer Methode dieses Objekts.

Für die Klasse gibt es zwei Möglichkeiten:

Subklasse von Thread

Implementierung des Runnable-Interface

Der Thread-Konstruktor und die Thread-Methoden start() und join() haben die folgenden Spezifikationen.

   public Thread(Runnable target)
   public Thread(Runnable target, String name)
   public Thread(ThreadGroup group, Runnable target, String name)
   public synchronized void start()
   public final void join() throws InterruptedException

erster Eindruck eines parallelen Java-Programms:

      class Action implements Runnable {
         int var;
         public Action(int v) { var = v; }
         public void run() { doSomeWork(var);  }
      }
      Thread t1 = new Thread(new Action(1));
      Thread t2 = new Thread(new Action(2));
      Thread t3 = new Thread(new Action(3));
      try {
          t1.start(); t2.start(); t3.start();
          t1.join(); t2.join(); t3.join();
      }
      catch (InterruptedException e) { ... }

2.2 Synchronisation von kritischen Bereichen

In verschiedenen run()-Methoden u.U. gleichzeitiger Zugriff auf globale Variablen.

Wir können nicht verhindern, daß Schreib- oder Lese-Operationen auf den globalen Speicher in nebenläufigen Prozessen stattfinden und sichtbar werden.

Das Java-Sprachkonstrukt synchronized hat die folgenden Varianten.

      synchronized (object) { ... }
      synchronized (static object) { ... }
      synchronized type methodName(...) { ... }
      static synchronized type methodName(...) { ... }

Die Semantik von synchronized type methodName(...) { S1; ...; Sn; }
entspricht

      type methodName(...) {
           synchronized(this) { S1; ...; Sn; }
      }

2.3 Warten auf Bedingungen

Problem: Initialisierung innerhalb eines parallelen Ablaufs.
Beispiel: Summe von Vektoren.

Zur Verfügung stehen uns die Object-Funktionen wait() und notify() mit den folgenden Spezifikationen:

    public final void wait() throws InterruptedException
    public final void wait(long timeout) 
                           throws InterruptedException
    public final void notify()
    public final void notifyAll()

wait() nur innerhalb eines synchronized Abschnitts

Fall eines beliebigen Booleschen Ausdrucks der erfüllt sein soll.

2.4 Zusammenfassung

2.5 Beispiele

Abbildung A: UML ExCon
UML ExCon

Abbildung B: UML ExAtom
UML ExAtom

Abbildung C: UML Semaphore
UML Sema

Abbildung D: UML Barrier
UML Barrier


© Universität Mannheim, Rechenzentrum, 2000-2001.

Last modified: Mon Apr 30 09:14:10 MEST 2001