Threads in Java

Stellen Sie sich zum Beispiel vor, Ihr Programm hat einen Hauptthread, der für die Anzeige der Benutzeroberfläche verantwortlich ist. Gleichzeitig können Sie einen zusätzlichen Thread erstellen, um Daten zu laden aus dem Netzwerk oder komplexe Berechnungen durchzuführen. Dies hilft, das Programm reaktionsfähiger und effizienter zu machen.

Wie kann man einen Thread in Java deklarieren

Verwendung der Thread-Klasse

Mit der Thread: Klasse können Sie eine Unterklasse der Thread-Klasse erstellen und die run() -Methode überschreiben, die den Code enthält, der im neuen Thread ausgeführt wird.

Main


              123456789
            
// Create a new thread using an anonymous subclass of `Thread`
Thread thread = new Thread() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Start the thread execution
thread.start();

Verwendung des Runnable-Interfaces

Mit dem Runnable Interface, können Sie das Runnable Interface implementieren, eine run() Methode bereitstellen und sie dem Konstruktor der Thread Klasse übergeben.

Main


              123456789101112
            
// Create a new `Runnable` instance with an anonymous class implementing the run method
Runnable runnable = new Runnable() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Create a new `Thread` instance, passing the `Runnable` as argument
Thread thread = new Thread(runnable);

// Start the thread execution
thread.start();

Vererbung der Thread-Klasse

Alternativ können Sie die Thread-Klasse erben und die run()-Methode überschreiben.

Main


              123456789
            
// The `MyThread` class extends the `Thread` class to create a custom thread
public class MyThread extends Thread {

    // The run method is overridden to define the task that the thread will execute
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}

Implementierung des Runnable-Interfaces

Sie können auch das Runnable-Interface implementieren und darin die run()-Methode implementieren:

Main


              123456789
            
// The `MyThread` class implements the `Runnable` interface to create a custom task
public class MyThread implements Runnable {

    // The run method is overridden to define the task that will be executed when the thread runs
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}

Hinweis

Die run() Methode in einem Java Thread ermöglicht es Ihnen, Code in einem separaten Thread auszuführen, einschließlich Aufgaben wie der Arbeit mit Daten, Berechnungen, dem Herunterladen von Dateien und dem Senden oder Empfangen von Daten über das Netzwerk.

Was ist der Unterschied zwischen Thread und Runnable?

In Java ist ein Thread ein spezieller Kanal, der die gleichzeitige Ausführung von Aufgaben ermöglicht, sodass Ihr Programm Operationen in einem separaten Thread ausführen kann, wie z.B. Berechnungen oder langlaufende Prozesse wie das Laden von Daten.

Das Runnable Interface, mit seiner einzigen run() Methode, definiert eine Aufgabe, die von einem Thread ausgeführt werden soll. Sie können eine Runnable Implementierung an einen Thread Konstruktor übergeben, um die Aufgabe in einem neuen Thread auszuführen. Diese Methode hilft dabei, parallele Aufgaben effizient zu verwalten und auszuführen.

Welche Methoden gibt es für Threads in Java?

Lassen Sie uns einen Thread starten mit der start() Methode, die angibt, dass der Code in einem neuen Thread ausgeführt werden soll. Das bedeutet, dass der Haupt-Thread weiterhin seinen eigenen Code ausführt und nicht wartet, bis der neu gestartete Thread abgeschlossen ist.

Main


              1234567891011121314151617181920212223242526
            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a new thread that will sleep for 5 seconds
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(5000); // Simulate work by sleeping for 5 seconds
            } catch (InterruptedException e) {
                throw new RuntimeException(e); // Handle interruption by rethrowing as a runtime exception
            }
        });

        // Start the thread
        thread.start();

        // Check if the thread is alive before calling `join()`
        System.out.println("Is the thread alive before the join() method: " + thread.isAlive());

        // Wait for the thread to finish execution
        thread.join();

        // Check if the thread is alive after `join()`
        System.out.println("Is the thread alive after join(): " + thread.isAlive());
    }
}

Wir haben auch eine Methode für den Haupt-Thread, um auf die Ausführung des von ihm gestarteten Threads zu warten, indem wir die join() Methode verwenden. Diese Methode wartet, bis der Thread vollständig ausgeführt ist. Sie können überprüfen, ob der Thread derzeit läuft, indem Sie die isAlive() Methode verwenden.

Der Code Thread.sleep(5000) pausiert den Thread für 5000 Millisekunden (5 Sekunden).

Im Beispiel, bevor join() aufgerufen wird, war der Thread am Arbeiten. Nach dem Aufruf von join() ist er es nicht mehr, da join() bedeutet, dass wir an diesem Punkt warten, bis der Thread seine Ausführung beendet hat.

Wenn wir einen Thread stoppen möchten, können wir die interrupt() Methode verwenden. Damit sie jedoch funktioniert, müssen wir überprüfen, ob der Thread, den wir stoppen, unterbrochen ist.

Main


              123456789101112131415161718192021222324252627282930313233
            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a thread that will perform some task
        Thread thread = new Thread(() -> {
            // Loop runs until the thread is interrupted
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread is running...");

                // Simulate some work with a delay
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Thread was interrupted during sleep.");
                    // Re-interrupt the thread to ensure the loop exits
                    Thread.currentThread().interrupt();
                }
            }

            System.out.println("Thread is exiting...");
        });

        // Start the thread
        thread.start();

        // Let the thread run for a bit
        Thread.sleep(3000);

        // Interrupt the thread
        thread.interrupt();
    }
}

Dieses Beispiel erstellt einen Thread, der eine Aufgabe in einer Schleife ausführt, bis er unterbrochen wird. Wenn der Thread während des Schlafens unterbrochen wird, wirft er eine Ausnahme, behandelt sie, indem er das Interrupt-Flag setzt, und beendet sich dann.

Ohne einen InterruptedException Ausnahme-Handler im Thread würde der Thread nicht unterbrochen werden.

Hinweis

Diese Methoden ermöglichen es Ihnen, den Lebenszyklus und die Ausführung von Threads in Java zu verwalten, und bieten Flexibilität und Kontrolle über Multithread-Anwendungen. In den folgenden Kapiteln werden wir mehr über diese Methoden erfahren.

1. Was ist ein Thread in Java?

2. Was ist der Unterschied zwischen der Thread-Klasse und dem Runnable-Interface in Java?

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 3