JAVA Threads

Überblick

Im wesentlichen besprechen wir drei Gruppen von Routinen:

1. con ... end: Erzeugung und Beendung von Threads:
   to = new Thread(Runnable),
   to.start(),
   to.join(), to.stop()

2. atomic ... end: Atomare Bereiche:
   synchronized method,
   synchronized static method,
   synchronized object
   

3. await cond ... end: Signale, Ereignisse
   wait(),
   notify(),
   notifyAll()

Thread Generierung

• Subklasse von Thread Klasse
• Implementierung von Runnable Interface

Zur Implementierung des con Sprachkonstruktes müssen wir die Statements (Si) in 'Runnable' Klassen Pi packen.

     class Pi implements Runnable {
       public void run() {
       Si;
       }
     }

Damit ist con S1, S2, ... Sn end ==

      Thread t1 = new Thread(new P1());
      Thread t2 = new Thread(new P2());
      ...
      Thread tn = new Thread(new Pn());


      t1.start();
      t2.start();
      ...
      tn.start();


      t1.join();
      t2.join();
      ...
      tn.join();

Beispiel 1

Thread Synchronisation

3 Möglichkeiten

• synchronized (Object) { statements }
  Object Synchronisation

• synchronized method
  Synchronisation von Methoden von Klasseninstanzen

• synchronized static method
  Synchronisation von statischen Methoden von Klassen

Probleme durch Implementierung:

• Definition von atomic
  Kein interner Zustand ist von aussen sichtbar

• Realisierung durch Warten:
  wer die internen Zustände nicht sehen darf, wartet bis die interne Verarbeitung abgeschlossen ist

• Warten verlangt Konvention:
  wer wartet wann und wo ?

Zur Implementierung des atomic Sprachkonstruktes müssen wir die Statements (S1, S2, ..., Sn) durch ein synchronized Sprachkonstrukt auf ein Objekt (z.B. atom) absichern.

     public static Object atom = new Object();

Damit ist atomic S1, S2, ... Sn end ==

     synchronized (atom) { S1, S2, ..., Sn; }

Beispiel 2

Beispiel 5

Thread Signaling

3 Möglichkeiten

• wait() Warten bis zum Signal
• notify() abgeben eines Signals an einen Thread
• notifyAll() abgeben eines Signals an alle Threads
• wait() Varianten mit Zeitlimit

wait() darf nur innerhalb von synchronized Programmteilen verwendet werden. Dies wird vom Compiler und vom Laufzeitsystem überwacht.

Zur Implementierung des await Sprachkonstruktes müssen wir die Arbeit auf einen Tester und einen Waiter aufteilen.

Initialization

     public static Object atom = new Object();

Damit ist await cond [ then S1, S2, ..., Sn ] end ==

Waiter:

     synchronized (atom) { 
        atom.wait();
        S1, S2, ..., Sn; 
     }

Tester:

     if ( cond ) { atom.notify(); }

An allen Programmstellen, an denen sich cond ändern könnte muß ein Tester-Teil eingefügt werden.

Semaphoren, sema.java

barrier-0.java, barrier.java, Example 6,

Weihnachtsaufgabe

[Previous] [Next] [Contents]