Java Thread

// Konstruktor
Thread(Runnable target)
Thread(Runnable target, String name)
 
// Damit kann von überall im Programm auf das gerade ausführende Thread-Objekt zugegriffen werden.
static currentThread()
 
// Gibt den Namen des Threads zurück bzw. setzt den Namen des Threads.
String getName()
void setName(String name)
 
// Beginnt die Ausführung des Threads, die JVM ruft intern die run()-Methode auf.
void start()
 
// Lässt den gerade ausführenden Thread für die angegebene Zeit (in Millisekunden) schlafen.
static void sleep(long milliseconds) throws InterruptedException
 
// Bricht die Ausführung dieses Threads ab; löst bei anderen Threads, die auf diesen Thread warten, eine entsprechende InterruptedException aus; ebenso bei diesem Thread, sofern dieser "schläft".
void interrupt()
 
// Blockiert den aufrufenden Thread solange, bis dieser Thread beendet ist.
void join()
 
// Markiert diesen Thread als „Daemon“-Thread. Kann nur vor dem Start des Threads geändert werden.
void setDaemon(boolean on = false)
 
// Hinweis für den "Scheduler" (JVM), dass der aktuelle Thread bereit ist, seine verbleibende Rechenzeit ("Zeitscheibe") anderen Threads zur Verfügung zu stellen.
static void yield()
 
// Gibt Priorität des Threads zurück bzw. setzt die Priorität des Threads
int getPriority()
void setPriority(int priority)
 
// Vom Interface Runnable vererbte Methode. Darf nicht aufgerufen werden – da sonst blockierender Aufruf! Wird intern durch den Aufruf der Methode start() genutzt.
void run()

Siehe auch

• Runnable

Methoden

currentThread

Sie gibt eine Referenz auf den aktuellen Thread zurück, der sich dann z.B. nach seinem Namen befragen lässt:

Runnable task = () -> System.out.println
    (Thread.currentThread().getName());
 
System.out.println(Thread.currentThread().getName());
new Thread(task, "Thread 1").start();
new Thread(task, "Thread 2").start();
new Thread(task, "Thread 3").start();

Ausgabe:

main
Thread 1
Thread 2
Thread 3

sleep

• Threads können mit sleep(long millis) für eine angegebene Dauer von Millisekunden pausiert werden.
• Die Pause kann von außen interrupted werden, dies löst eine InterruptedException aus. Diese muss gecached werden.

try {
    Thread.sleep(200);
} catch (InterruptedException e) {
    // ...
}

join

• Die Methode join() bewirkt, dass der aktuelle Thread auf Beendigung des Threads wartet.
• Wie bei sleep() kann diese Methode auch interrupted werden.

Thread t1 = new Thread(task);
 
try {
    t1.join(); t2.join();
} catch (InterruptedException e) {
    // ...
}

Threads per Interrupt unterbrechen

• Jeder Thread hat ein Interrupt-Flag (normalerweise zurückgesetzt).
• Wenn es gesetzt ist und der Thread sleep oder join ausführt, dann wird eine InterruptedException geworfen.
• Der Thread entscheidet dann, was zu tun ist. Das Spektrum reicht vom ignorieren der Ausnahme bis zur Beendigung des Threads.
• Das Flag wird nach jeder Exception wieder zurückgesetzt. Will man es beibehalten, muss man es explizit wieder setzen:

catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

Auswahl an Thread- und Interrupt-Funktionen

// Gibt die Referenz auf den aktuellen Thread zurück
public static Thread currentThread()
 
// Setzt das Interrupt-Flag eines Threads.
// Bsp: Thread t = new Thread(...); t.start(); t.interrupt();
public void interrupt();
 
// Frägt das Interrupt-Flag des aktuellen Threads ab.
// Das Interrupt-Flag wird danach wieder zurückgesetzt.
// Bsp: while(!Thread.interrupted()) { ... }
public static boolean interrupted();
 
// Frägt das Interrupt-Flag des aktuellen Threads ab.
// Das Interrupt-Flag wird dabei nicht verändert.
// Bsp: while(!Thread.currentThread().isInterrupted()) { ... }
public boolean isInterrupted()