Java - Thread Scheduler

Hallo dort, zukünftige Java-Zauberer! Heute werden wir auf eine aufregende Reise in die Welt der Java-Thread-Scheduling einsteigen. Keine Sorge, wenn du neu bei der Programmierung bist – ich werde dein freundlicher Guide sein, und wir werden dieses Thema Schritt für Schritt angehen. Also nimm deine virtuellen Zauberstäbe (Tastaturen) und lass uns einsteigen!

Was ist Thread Scheduling?

Bevor wir in die Details einsteigen, lassen Sie uns verstehen, was Thread Scheduling bedeutet. Stell dir vor, du bist ein Zirkus-Direktor (das ist die Java-Laufzeitumgebung), und du hast mehrere Artisten (Threads), die auf ihre Auftritte warten. Deine Aufgabe ist es, zu entscheiden, welcher Artist auf die Bühne kommt und wie lange. Das ist im Grunde genommen, was Thread Scheduling in Java macht – es verwaltet mehrere Threads und entscheidet, welcher Thread wann läuft.

Warum brauchen wir Thread Scheduling?

Du fragst dich vielleicht, "Warum lassen wir nicht einfach alle Threads laufen, wann immer sie möchten?" Nun, stell dir vor, wenn alle Zirkusartisten gleichzeitig auftreten würden – das wäre Chaos! Thread Scheduling hilft, Ordnung zu erhalten, stellt sicher, dass Ressourcen fair verteilt werden, und verbessert die gesamte Systemleistung.

Java's Thread Scheduler

Java hat einen eingebauten Thread-Scheduler, der diese komplexe Aufgabe für uns erledigt. Er verwendet eine Kombination aus Betriebssystemebene-Scheduling und eigenen Algorithmen, um Threads effizient zu verwalten.

Thread-Status

Bevor wir ins Scheduling einsteigen, lassen uns schnell die verschiedenen Zustände überprüfen, in denen ein Thread sein kann:

1. Neu
2. Ausführbar
3. Läuft
4. Blockiert/Wartet
5. Beendet

Der Scheduler ist verantwortlich für das Bewegen von Threads zwischen diesen Zuständen.

Grundlegende Thread-Erstellung und Scheduling

Lassen Sie uns mit einem einfachen Beispiel beginnen, um zu sehen, wie Java Threads erstellt und plant:

public class SimpleThreadExample {
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Thread 1: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

Thread thread2 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Thread 2: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

thread1.start();
thread2.start();
}
}

In diesem Beispiel erstellen wir zwei Threads, die Zahlen von 0 bis 4 ausgeben. Der Aufruf Thread.sleep(1000) lässt jeden Thread für 1 Sekunde zwischen den Ausgaben pausieren.

Wenn Sie dieses Programm ausführen, werden Sie bemerken, dass die Ausgabe vielleicht nicht in einer perfekten alternierenden Reihenfolge ist. Das liegt daran, dass der Java-Scheduler entscheidet, wann er zwischen Threads wechselt!

Thread-Prioritäten

Java ermöglicht es uns, dem Scheduler Hinweise zu geben, welche Threads wichtiger sind. Wir können Thread-Prioritäten mit der Methode setPriority() setzen. Lassen Sie uns unser vorheriges Beispiel ändern:

public class ThreadPriorityExample {
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Niedrige Priorität Thread: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

Thread thread2 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Hoch Priorität Thread: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

thread1.setPriority(Thread.MIN_PRIORITY);
thread2.setPriority(Thread.MAX_PRIORITY);

thread1.start();
thread2.start();
}
}

In diesem Beispiel setzen wir thread1 auf die niedrigste Priorität und thread2 auf die höchste Priorität. Während das nicht garantiert, dass thread2 immer zuerst oder öfter läuft, gibt es dem Scheduler einen Hinweis, dass er thread2 wenn möglich bevorzugen sollte.

ScheduledExecutorService

Nun schauen wir uns eine fortgeschrittene Methode zur Planung von Threads mit ScheduledExecutorService. Dieses leistungsstarke Werkzeug ermöglicht es uns, Aufgaben zu planen, die nach einer Verzögerung oder in festen Intervallen ausgeführt werden.

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExecutorExample {
public static void main(String[] args) {
ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);

Runnable task1 = () -> System.out.println("Task 1 ausgeführt um: " + System.currentTimeMillis());
Runnable task2 = () -> System.out.println("Task 2 ausgeführt um: " + System.currentTimeMillis());

executor.schedule(task1, 5, TimeUnit.SECONDS);
executor.scheduleAtFixedRate(task2, 0, 2, TimeUnit.SECONDS);

try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}

executor.shutdown();
}
}

In diesem Beispiel:

• Wir erstellen einen ScheduledExecutorService mit 2 Threads.
• task1 wird einmal nach einer 5 Sekunden Verzögerung ausgeführt.
• task2 wird alle 2 Sekunden ausgeführt, beginnend sofort.
• Wir lassen das Programm für 10 Sekunden laufen, bevor wir den Executor herunterfahren.

Dies zeigt, wie wir präzise kontrollieren können, wann und wie oft unsere Aufgaben ausgeführt werden.

Methoden von ScheduledExecutorService

Hier ist eine Tabelle der Hauptmethoden, die von ScheduledExecutorService bereitgestellt werden:

Methode	Beschreibung
schedule(Runnable, long, TimeUnit)	Plant eine einmalige Aufgabe, die nach einer angegebenen Verzögerung ausgeführt wird
scheduleAtFixedRate(Runnable, long, long, TimeUnit)	Plant eine Aufgabe, die periodisch ausgeführt wird, mit einer festen Verzögerung zwischen dem Start jeder Ausführung
scheduleWithFixedDelay(Runnable, long, long, TimeUnit)	Plant eine Aufgabe, die periodisch ausgeführt wird, mit einer festen Verzögerung zwischen dem Ende einer Ausführung und dem Beginn der nächsten

Fazit

Und so haben es die Leute! Wir haben die Grundlagen des Java-Thread-Schedulings durchlaufen, von der einfachen Thread-Erstellung bis zum fortgeschrittenen Scheduling mit ScheduledExecutorService. Denken Sie daran, Thread Scheduling ist wie das Dirigieren eines Orchesters – es geht um Harmonie und Timing.

Während Sie Ihre Java-Abenteuer fortsetzen, werden Sie noch mehr Wege entdecken, um das Verhalten von Threads zu verfeinern. Aber jetzt, klopfen Sie sich auf die Brust – Sie haben einen großen Schritt in die Welt der并发 Programming gemacht!

Üben Sie weiter, bleiben Sie neugierig und above all, haben Sie Spaß beim Coden! Wer weiß, vielleicht schreibst du eines Tages die nächste Generation von Java-Thread-Schedulern. Bis dahin, happy threading!

Credits: Image by storyset