Java -Threads
Java-Threads
Threads ermöglichen es einem Programm, effizienter zu arbeiten, indem mehrere Dinge gleichzeitig ausgeführt werden.
Threads können verwendet werden, um komplizierte Aufgaben im Hintergrund auszuführen, ohne das Hauptprogramm zu unterbrechen.
Thread erstellen
Es gibt zwei Möglichkeiten, einen Thread zu erstellen.
Es kann erstellt werden, indem die Klasse erweitert und ihre
Methode Threadüberschrieben wird:run()
Syntax erweitern
public class Main extends Thread { public void run() { System.out.println("This code is running in a thread");}}
Eine andere Möglichkeit, einen Thread zu erstellen, besteht darin, die RunnableSchnittstelle zu implementieren:
Syntax implementieren
public class Main implements Runnable {
public void run() {
System.out.println("This code is running in a thread");
}
}Laufende Fäden
Wenn die Klasse die ThreadKlasse erweitert, kann der Thread ausgeführt werden, indem eine Instanz der Klasse erstellt und ihre start()Methode aufgerufen wird:
Beispiel erweitern
public class Main extends Thread {
public static void main(String[] args) {
Main thread = new Main();
thread.start();
System.out.println("This code is outside of the thread");
}
public void run() {
System.out.println("This code is running in a thread");
}
}
Wenn die Klasse die RunnableSchnittstelle implementiert, kann der Thread ausgeführt werden, indem eine Instanz der Klasse an Threadden Konstruktor eines Objekts übergeben und dann die
start()Methode des Threads aufgerufen wird:
Beispiel implementieren
public class Main implements Runnable {
public static void main(String[] args) {
Main obj = new Main();
Thread thread = new Thread(obj);
thread.start();
System.out.println("This code is outside of the thread");
}
public void run() {
System.out.println("This code is running in a thread");
}
}
Unterschiede zwischen „Erweitern“ und „Implementieren“ von Threads
Der Hauptunterschied besteht darin, dass Sie, wenn eine Klasse die Thread-Klasse erweitert, keine andere Klasse erweitern können, aber durch die Implementierung der Runnable-Schnittstelle ist es möglich, auch von einer anderen Klasse zu erweitern, wie zum Beispiel: class MyClass extends OtherClass implements Runnable.
Parallelitätsprobleme
Da Threads zur gleichen Zeit wie andere Teile des Programms ausgeführt werden, gibt es keine Möglichkeit zu wissen, in welcher Reihenfolge der Code ausgeführt wird. Wenn die Threads und das Hauptprogramm dieselben Variablen lesen und schreiben, sind die Werte unvorhersehbar. Die daraus resultierenden Probleme werden Nebenläufigkeitsprobleme genannt.
Beispiel
Ein Codebeispiel, bei dem der Wert des variablen Betrags unvorhersehbar ist:
public class Main extends Thread { public static int amount = 0; public static void main(String[] args) { Main thread = new Main(); thread.start(); System.out.println(amount); amount++; System.out.println(amount);}public void run() { amount++;}}
Um Parallelitätsprobleme zu vermeiden, empfiehlt es sich, möglichst wenige Attribute zwischen Threads gemeinsam zu nutzen. Wenn Attribute gemeinsam genutzt werden müssen, besteht eine mögliche Lösung darin, die isAlive()
Methode des Threads zu verwenden, um zu prüfen, ob der Thread seine Ausführung beendet hat, bevor Attribute verwendet werden, die der Thread ändern kann.
Beispiel
Verwenden Sie isAlive(), um Parallelitätsprobleme zu vermeiden:
public class Main extends Thread { public static int amount = 0; public static void main(String[] args) { Main thread = new Main(); thread.start(); // Wait for the thread to finish while(thread.isAlive()) { System.out.println("Waiting...");}// Update amount and print its value System.out.println("Main: " + amount); amount++; System.out.println("Main: " + amount);}public void run() { amount++;}}