Java - Erstellung eines Threads

Hallo da draußen, zukünftige Java-Zauberer! Heute tauchen wir ein in die aufregende Welt der Java-Threads. Machen Sie sich keine Sorgen, wenn Sie neu im Programmieren sind; ich werde Sie auf dieser Reise Schritt für Schritt führen, genau wie ich es über die Jahre mit unzähligen Schülern getan habe. Also holen Sie sich Ihr lieblings Getränk, machen Sie es sich gemütlich, und lassen Sie uns gemeinsam diese Thread-Abenteuerreise antreten!

Was ist ein Thread?

Bevor wir in die Erstellung von Threads einsteigen, lassen Sie uns verstehen, was ein Thread überhaupt ist. Stellen Sie sich vor, Sie sind in einer Küche und kochen ein köstliches Gericht. Sie schneiden Gemüse, rühren die Sauce und überprüfen den Ofen gleichzeitig. Jede dieser Aufgaben ist wie ein Thread in einem Computerprogramm - sie sind separate Aufgaben, die gleichzeitig ausgeführt werden können.

In Java ist ein Thread die kleinst mögliche Ausführteinheit innerhalb eines Programms. Er ermöglicht es verschiedenen Teilen Ihres Programms, gleichzeitig zu laufen, was Ihre Anwendungen effizienter und responsiver macht.

Warum Threads verwenden?

Vielleicht fragen Sie sich, warum Sie sich mit Threads beschäftigen sollten. Lassen Sie mich Ihnen eine kleine Geschichte erzählen. Vor Jahren habe ich eine einfache Bildbearbeitungsanwendung für einen Fotografenclub entwickelt. Die App funktionierte gut für kleine Bilder, aber wenn Benutzer versuchten, große, hochauflösende Fotos zu verarbeiten,freezte sie ein. Der Schuldige? Alles lief auf einem einzigen Thread! Durch die Implementierung von Multithreading konnten wir Bilder im Hintergrund verarbeiten und die Benutzeroberfläche responsive halten. Die Mitglieder des Fotografenclubs waren begeistert, und ich habe eine wertvolle Lektion über die Macht der Threads gelernt.

Erstellung eines Threads in Java

In Java gibt es zwei Hauptwege, um einen Thread zu erstellen:

1. Implementierung des Runnable-Interfaces
2. Vererbung von der Thread-Klasse

Lassen Sie uns beide Methoden mit einigen praktischen Beispielen erkunden!

Methode 1: Implementierung des Runnable-Interfaces

Dies wird oft als bevorzugte Methode zur Erstellung eines Threads angesehen, da sie nicht erfordert, dass Sie Thread unterklassieren, was es Ihrer Klasse ermöglicht, andere Klassen zu erweitern, falls nötig.

Hier ist ein einfaches Beispiel:

public class MyRunnable implements Runnable {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("Thread mit Runnable: " + i);
try {
Thread.sleep(1000); // Pause für 1 Sekunde
} catch (InterruptedException e) {
System.out.println("Thread unterbrochen.");
}
}
}

public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

// Hauptthread
for (int i = 1; i <= 5; i++) {
System.out.println("Hauptthread: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.println("Hauptthread unterbrochen.");
}
}
}
}

Lassen Sie uns das zusammenbrechen:

1. Wir erstellen eine Klasse MyRunnable, die das Runnable-Interface implementiert.
2. Wir überschreiben die run()-Methode, die definiert, was der Thread machen wird, wenn er gestartet wird.
3. In der main-Methode erstellen wir eine Instanz von MyRunnable und übergeben sie an ein neues Thread-Objekt.
4. Wir rufen start() auf dem Thread auf, um seine Ausführung zu beginnen.
5. Der Hauptthread gibt auch Zahlen aus, um zu zeigen, wie beide Threads gleichzeitig laufen.

Wenn Sie dieses Programm ausführen, werden Sie sehen, dass die Zahlen beider Threads vermischt werden, was zeigt, dass sie gleichzeitig laufen!

Methode 2: Vererbung von der Thread-Klasse

Diese Methode beinhaltet das Erstellen einer Unterklasse von Thread und das Überschreiben ihrer run()-Methode. Hier ist ein Beispiel:

public class MyThread extends Thread {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("Thread, der von Thread-Klasse erbt: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.println("Thread unterbrochen.");
}
}
}

public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();

// Hauptthread
for (int i = 1; i <= 5; i++) {
System.out.println("Hauptthread: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.println("Hauptthread unterbrochen.");
}
}
}
}

Die wichtigsten Unterschiede hier sind:

1. Unsere Klasse MyThread erweitert Thread anstatt Runnable zu implementieren.
2. Wir können direkt start() auf unser MyThread-Objekt aufrufen, ohne eine separate Thread-Instanz erstellen zu müssen.

Vergleich der beiden Methoden

Beide Methoden erreichen das gleiche Ergebnis, aber es gibt einige Überlegungen:

Eigenschaft	Runnable-Interface	Erweiterung der Thread-Klasse
Flexibilität	Kann andere Klassen erweitern	Kann keine anderen Klassen erweitern (Java unterstützt keine Mehrfachvererbung)
Trennung von Verantwortlichkeiten	Trennt die Aufgabe vom Thread	Kombiniert die Aufgabe und den Thread in einer Klasse
Wiederverwendbarkeit	Höher wiederverwendbar	Weniger wiederverwendbar
Ressourceneffizienz	Höher effizient (kann mit Thread-Pools verwendet werden)	Weniger effizient

In den meisten Fällen wird die Implementierung von Runnable als bessere Praxis angesehen, da sie mehr Flexibilität bietet und besser mit den Prinzipien der objektorientierten Programmierung übereinstimmt.

Schlussfolgerung

Glückwunsch! Sie haben gerade Ihre ersten Schritte in die Welt der Java-Threads unternommen. Wir haben die Grundlagen dessen, was Threads sind, warum sie nützlich sind, und wie man sie mit zwei verschiedenen Methoden erstellt, behandelt. Erinnern Sie sich daran, dass das Beherrschen von Threads wie das Lernen, Jonglieren zu können, Übung erfordert. Lassen Sie sich nicht entmutigen, wenn es nicht sofort klappt - experimentieren Sie weiter, und Sie werden es schaffen!

In meiner nächsten Lektion tauchen wir tiefer in die Thread-Synchronisation und die Kommunikation zwischen Threads ein. Bis dahin, viel Spaß beim Coden, und mögen Ihre Threads immer reibungslos laufen!

Credits: Image by storyset