VHPD Blog Blog for [V]ideo, [H]ardware, [P]rograms, [D]ata and more..

Grundlagen der Informatik – Semaphore (Thread Steuerung)

Grundlagen der Informatik - Semaphore (Thread Steuerung)

Wenn man mit Threads arbeitet, muss man aufpassen, dass die Threads sich nicht gegenseitig blockieren. Deshalb sollte man beachten, ob der Thread in einen kritischen Zustand gerät. Bevor dieser in einen kritischen Zustand kommt, soll gefragt werden, ob ein anderer bereits darin ist. Damit sich die Threads nicht in die Quere kommen.

Kritischer Zustand

Ein kritischer Zustand ist eine Sequenz von einem Thread, die durch das einwirken eines anderen Threads manipuliert bzw. blockiert werden kann. In dem kritischen Zustand kann das Programm abstürzen oder schwere Fehler verursachen. Kommen oft zustande wenn mehrere Threads auf die gleiche Variable bzw. Attribut zugreifen wollen.

Im kritischen Zustand können somit zwei Threads verklemmen!

In Java kann man eine Semaphore so programmieren:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Semaphore {
    private int value;
    public Semaphore(int pInit) {
        if (pInit < 0) {
            pInit = 0;
        }
        value = pInit;
    }
 
    public synchronized void down() {
        while (value == 0) {
            try {
                wait();
            } catch (InterruptedException exp) {
            }
        }
        value--;
    }
 
    public synchronized void up() {
        value++;
        notifyAll();
    }
 
}

In dem Konstruktor der Semaphore wird ein Integerwert übergeben, wie viele Threads auf einmal in den überwachten kritischen Zustand kommen dürfen. Natürlich kann dieser Wert nicht kleiner als 0 sein und auch 0 macht wenig sinn, da sonst kein Thread den kritischen Zustand erlangen kann.

In Unserem Beispiel setzten wir den value-Wert auf 1. Wir haben 2 Threads die in einen kritischen Zustand kommen.

Wenn jetzt nun unser 1. Thread in den Zustand kommen möchte, ruft diese den Befehl down() auf. Nun wird value auf 0 gesetzt und unser 1. Thread kann arbeiten. Sollte jetzt der 2. Thread kommen, dann bleibt er bei der Abfrage value == 0 hängen und wartet nun passiv.

Wenn unser 1. Thread nun den kritischen Zustand verlässt wird value wieder auf 1 gesetzt und mittels notifyAll() werden die wartenden Threads geweckt. Der erste der nun geweckt wurde, kann nun den kritischen Zustand erreichen. In unserem Beispiel ist nun der 2. Thread in der Lage den kritischen Zustand zu erreichen.

Klar ist, dass die Semaphore die gleiche sein muss, die beide Threads verwenden. Weil wenn jeder Thread seine eigene Semaphore hat, werden beide nahezu gleichzeitig in den kritischen Zustand wechseln.

Eine Semaphore kann man sich wie eine Ampel vorstellen, die den "Verkehr" regelt. Hierbei kann sie Threads in die Warteliste schieben und auch wieder in den bereiten Zustand ändern.