• Schlafen für Profis
• Thread, der Hintergrundarbeiter
• Das Interface Runnable
• Threadkontrolle ist ein Kinderspiel - oder nicht?
• Auf das Thread-Ende warten (join)
• Kritischer Bereich
• Auf Objekte warten (wait/notify)
• Statt warten auf Godot: Time-Out
• Timer in den GUI-APIs: Beispiel Swing
• Videos

Zu dem Thema gibt es zwei Videos auf Youtube

Schlafen für Profis

while (!fertig) {
    // nichts tun: busy waiting oder polling! Böse!
}

Stattdessen bieten alle Systeme einen Mechanismus Sleep an. Sleep sorgt für entspanntes Warten, weil der Thread inaktiv wird und anderen Threads den Prozessor überlässt.

try {
    Thread.sleep(1000); // 1000ms!
} catch (InterruptedException e) {
}

Das folgende Programm nutzt Sleep und zählt damit sekundenweise herunter.

public class CountDown {
    public static void main(String[] args) {
        for (int i = 10; i > 0; --i) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
    }
}

Thread, der Hintergrundarbeiter

Wenn Sie also die Klasse Thread erweitern und die Methode run überschreiben, können Sie darin den Code für Ihren Leichtgewichtsprozess ablegen.

import java.util.ArrayList;
import java.util.List;

public class GlockenThread extends Thread {

    private String meldung = "";
    private int anzahl = 0;
    private long zeit = 0;
    
    public GlockenThread(String meldung, int anzahl, long zeit) {
        this.meldung = meldung;
        this.anzahl = anzahl;
        this.zeit = zeit;
    }
    
    @Override
    public void run() {
        for (int i=0; <anzahl; i++) {
            try {
                Thread.sleep(zeit);
                System.out.println(meldung);
            } catch(InterruptedException e) {    
            }
        }
    }
    
    static Lis<Thread> gelaeut = new ArrayLis<Thread>();
    
    public static void main(String[] args) {
        Thread thread = new GlockenThread("bing", 10, 600);
        thread.start();
        thread = new GlockenThread("  bang", 15, 400);
        thread.start();
    }
}

Ein Leichtgewichtsprozess (Thread) endet mit dem Erreichen des Endes der Methode run.

Die Methode main bildet den Haupt-Thread. Das bedeutet, dass jedes Programm immer mindestens einen Thread besitzt. Ein Programm endet, wenn der letzte Thread des Programms endet. Das muss nicht der Haupt-Thread sein.

Das Interface Runnable

1. Das Interface Runnable implementieren, insbesondere dessen Methode run
2. Die Runnable-Implementierung als Parameter dem Konstruktor von Thread übergeben
3. Das Thread-Objekt über dessen Methode start starten

import java.util.ArrayList;
import java.util.List;

public class Glocken implements Runnable {

    private String meldung = "";
    private int anzahl = 0;
    private long zeit = 0;
    
    public Glocken(String meldung, int anzahl, long zeit) {
        this.meldung = meldung;
        this.anzahl = anzahl;
        this.zeit = zeit;
    }
    
    @Override
    public void run() {
        for (int i=0; i<anzahl; i++) {
            try {
                Thread.sleep(zeit);
                System.out.println(meldung);
            } catch(InterruptedException e) {    
            }
        }
    }
    
    public static void main(String[] args) {
        (new Thread(new Glocken("bing", 10, 600))).start();
        (new Thread(new Glocken("  bang", 15, 400))).start();
        (new Thread(new Glocken("    bong", 8, 800))).start();
    }
}

Threadkontrolle ist ein Kinderspiel - oder nicht?

• Alle Kinder sollen gemeinsam zur Oma. Die Abfahrt soll möglichst ohne Quengeln erfolgen.
  Lösung: Wir sammeln die Kinder ein, indem wir jedes einzeln ins Auto setzen, wenn es fertig gespielt hat. (join)
• Es gibt Spielzeug, das nur einer gleichzeitig nutzen kann. Das führt natürlich zu Streit.
  Lösung: Wir sperren die Geschwister ins Klo und lassen nacheinander immer nur ein Kind gleichzeitig spielen. (synchronized)
• Mama muss das kaputte Spielzeug reparieren.
  Lösung: Das Kind muss warten bis Mama ruft, dass das Spielzeug wieder heil ist. (wait, notify)
• Bettgehzeit: Es ist Schluss mit Spielen! Nun wollen die Kinder gar nicht mehr aufhören zu spielen.
  Lösung: Man unterbricht das Kind, nimmt ihm das Spielzeug weg und trägt es an den Ohren ins Bett. (interrupt)

Auf das Thread-Ende warten (join)

static List gelaeut = new ArrayList();
    
public static void main(String[] args) {
    gelaeut.add(new Thread(new Glocken("bing", 10, 600)));
    gelaeut.add(new Thread(new Glocken("  bang", 15, 400)));
    gelaeut.add(new Thread(new Glocken("    bong", 8, 800)));
    for (Thread thread : gelaeut) {
        thread.start();
    }
    for (Thread thread : gelaeut) {
        try {
            thread.join();
        } catch (InterruptedException e) {
        }
    }
    System.out.println("Guten Morgen, liebe Gemeinde!");
}

Kritischer Bereich

Die Klasse VasenOfen produziert eine Anzahl von Vasen. Das benötigt Zeit. Im Beispiel wurde die Zeit zufällig zwischen 0 und 100 ms angesetzt. Dann ruft sie den Verpacker zum verpacken der Vase.

public class VasenOfen implements Runnable {

    private int anzahl;
    private Verpacker verpacker;
    
    public VasenOfen(Verpacker verpackung, int anzahl) {
        this.verpacker = verpackung;
        this.anzahl = anzahl;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < anzahl; i++) {
            // Von Zeit zu Zeit wird eine Vase fertig
            try {
                Thread.sleep((long) (100 * Math.random()));
            } catch (InterruptedException e) {
            }
            // Verpacken ist ein kritischer Bereich!
            verpacker.verpacke();
        }
    }
}

public class Verpacker {

    private boolean bereitsAktiv = false;
    
    public void verpacke() {
        if (bereitsAktiv) {
            System.out.println("Klirr");
        } else {
            bereitsAktiv = true;
            System.out.print("Verpacke...");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }    
            System.out.println("...Verpackt");
        }
        bereitsAktiv = false; // fertig!
    }
    
}

public class VasenMain {

    public static void main(String[] args) {
        Verpacker verpacker = new Verpacker();
        for (int i=0; i<3; i++) {
            (new Thread(new VasenOfen(verpacker, 10))).start();
        }
    }
}

Der Zugang zur Verpackung ist ein kritischer Bereich: Es darf nur ein Thread gleichzeitig den Bereich betreten. Dafür kennt Java das Zauberwort synchronized. Es wird als Modifizierer vor die Methode verpacke gestellt und schon darf immer nur ein Thread gleichzeitig die Methode betreten.

public synchronized void verpacke()
{
    // ...
}

Auf Objekte warten (wait/notify)

Der Aufruf von wait legt den Aufrufer schlafen bis ein anderer Thread notify aufruft. Das Warte-Objekt ist aber selbst wieder ein kritischer Bereich und muss darum vor einem Aufruf von wait oder notify synchronized gesetzt werden. Syntaktisch sieht dies ähnlich wie ein if oder ein while aus:

synchronized(obj) {
    obj.wait();
}
// ...
synchronized(obj) {
    obj.notify();
}

Simuliert wird das durch die Methoden neuerKarton und verbraucheKarton in der Klasse Karton:

public class Karton {
    private int kartons = 0;
    
    public void neuerKarton(int anzahl) {
        synchronized(this) {
            kartons += anzahl;
            this.notify();
       }
    }
    
    public void verbraucheKarton() {
        synchronized(this) {
            while (kartons<=0) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            kartons--;
        }
    }
}

public class Verpacker {

    private boolean bereitsAktiv = false;
    private Karton karton;
    
    public Verpacker(Karton karton) {
        this.karton = karton;
    }

    public synchronized void verpacke() {
        if (bereitsAktiv) {
            System.out.println("Klirr");
        } else {
            bereitsAktiv = true;
            karton.verbraucheKarton();
            System.out.print("Verpacke...");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }    
            System.out.println("...Verpackt");
        }
        bereitsAktiv = false; // fertig!
    }
}

public class VasenMain {

    private static void liefereKartons(Karton karton) {
        for (int i=0; i<10; i++) {
            System.out.println("Liefere Kartons");            
            karton.neuerKarton(4);
            try {
                Thread.sleep(800);
            } catch (InterruptedException e) {
            }
        }        
    }
    public static void main(String[] args) {
        Karton karton = new Karton();
        Verpacker verpacker = new Verpacker(karton);
        for (int i=0; i<3; i++) {
            (new Thread(new VasenOfen(verpacker, 10))).start();
        }
        liefereKartons(karton);
    }
}

Statt warten auf Godot: Time-Out

Wir könnten auch das in der Vasenfabrik simulieren. Wenn dort die Uhr Feierabend anzeigt, unterbricht der Verpacker alles und geht nach Hause. Die Uhr unterbricht (interrupt) also die Tätigkeit des Verpackers.

Damit es nicht unübersichtlich wird, zeigt das Programm TimeOut diesen Unterbrechungsmechanismus anhand eines Threads, der auf ein Objekt wartet.

public class TimeOut implements Runnable {

    static private Object object = new Object();
    
    @Override
    public void run() {
        try {
            // Wir können nur auf ein Objekt zugreifen,
            // wenn wir es zuvor synchronisieren
            synchronized(object) {
                object.wait();
            }
            System.out.println("Ich ende regulär");
        } catch (InterruptedException e) {
            System.out.println("Ich wurde unterbrochen");
        }
    }
    
    public static void main(String[] args) {
        Thread thread = new Thread(new TimeOut());
        thread.start();
        try {
            Thread.sleep(200);
            // Unterbreche den Hintergrund-Thread:
            //thread.interrupt();
            Thread.sleep(200);
            // Löse das Ereignis aus, auf das der Thread wartet
            synchronized(object) {
                object.notify();
            }
        } catch (InterruptedException e) {
        }
    }
}

Timer in den GUI-APIs: Beispiel Swing

Das zeigt das folgende Beispiel, in dem der Geheimagent im letzten Moment die tickende Zeitbombe entschärft. Der erste Klick startet die Countdown. Danach kommt das Programm aber erst wieder zum Zuge, wenn die Methode countdown zum Ende kommt. Der Geheimagent hat keine Chance, die Zeitbombe zu entschärfen.

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;

/**
 * Ein Countdown ohne Thread blockiert die JFrame-Anwendung
 */

public class ZeitbombeBlockiert extends JFrame implements ActionListener {

    JLabel label = new JLabel("Tick");
    JButton button = new JButton("Start");
    boolean scharf = false;

    public void countdown() {
        for (int i = 10; i > 0; --i) {
            label.setText("" + i);
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
        label.setText("Bumm");
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (scharf) {
            button.setText("Start");
        } else {
            countdown();
            button.setText("Stopp");
        }
        scharf = !scharf;
    }

    public ZeitbombeBlockiert() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());
        button.addActionListener(this);
        add(BorderLayout.NORTH, label);
        add(BorderLayout.SOUTH, button);
        setVisible(true);
        pack();
    }
    
    public static void main(String[] args) {
        new ZeitbombeBlockiert();
    }
}

Eine Lösung besteht darin, längerwährende Aufgaben in einen Thread auszulagern.

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;

public class ZeitbombeThread extends JFrame implements Runnable, ActionListener {

    JLabel label = new JLabel("Tick", SwingConstants.CENTER);
    JButton button = new JButton("Start");
    Thread ticktack = null;

    @Override
    public void run() {
        for (int i = 10; i > 0; --i) {
            label.setText("" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                return;
            }
        }
        label.setText("Bumm");
        button.setText("Start");
        ticktack = null;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (ticktack != null) {
            ticktack.interrupt();
            ticktack = null;
            button.setText("Start");
        } else {
            ticktack = new Thread(this);
            ticktack.start();
            button.setText("Stopp");
        }
    }

    public ZeitbombeThread() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());
        button.addActionListener(this);
        add(BorderLayout.NORTH, label);
        add(BorderLayout.SOUTH, button);
        setVisible(true);
        setSize(200, 100);
    }

    public static void main(String[] args) {
        new ZeitbombeThread();
    }
}

Videos

Synchronisieren von Threads mit join, synchronized, wait-notify und interrupt.