Stellen Sie sich zum Beispiel vor, Ihr Programm verfügt über einen Haupt-Thread, der für die Anzeige der Benutzeroberfläche verantwortlich ist. Gleichzeitig können Sie einen zusätzlichen Thread erstellen, um Daten aus dem Netzwerk zu laden oder komplexe Berechnungen durchzuführen. Dies trägt dazu bei, das Programm reaktionsfähiger und effizienter zu gestalten.

Deklaration eines Threads in Java

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

Main.java


              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 kann das Runnable-Interface implementiert, eine run()-Methode bereitgestellt und an den Konstruktor der Thread-Klasse übergeben werden.

Main.java


              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 kann die Thread-Klasse geerbt und die run()-Methode überschrieben werden.

Main.java


              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

Es ist ebenfalls möglich, das Runnable-Interface zu implementieren und darin die Methode run() zu überschreiben:

Main.java


              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 die Ausführung von Code in einem separaten Thread, einschließlich Aufgaben wie Datenverarbeitung, Berechnungen, Herunterladen von Dateien sowie Senden oder Empfangen von Daten über das Netzwerk.

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 zum Beispiel Berechnungen oder lang andauernde 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 unterstützt die effiziente Verwaltung und Ausführung von parallelen Aufgaben.

Verfügbare Methoden für Threads in Java

Ein Thread wird gestartet mit der Methode start(), 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 darauf wartet, dass der neu gestartete Thread abgeschlossen wird.

Main.java


              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());
    }
}

Es gibt auch eine Methode, mit der der Hauptthread auf die Ausführung des von ihm gestarteten Threads warten kann, indem die join()-Methode verwendet wird. Diese Methode wartet, bis der Thread vollständig ausgeführt wurde. Ob der Thread aktuell läuft, kann mit der isAlive()-Methode überprüft werden.

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

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
}

Im Beispiel arbeitete der Thread, bevor join() aufgerufen wurde. Nach dem Aufruf von join() arbeitet er nicht mehr, da join() bedeutet, dass an dieser Stelle gewartet wird, bis der Thread seine Ausführung beendet hat.

Wenn ein Thread gestoppt werden soll, kann die interrupt()-Methode verwendet werden. Damit dies jedoch funktioniert, muss überprüft werden, ob der zu stoppende Thread unterbrochen wurde.

Main.java


              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, löst er eine Ausnahme aus, behandelt diese durch Setzen des Interrupt-Flags und beendet sich anschließend.

Ohne einen Ausnahmebehandler für InterruptedException im Thread würde der Thread nicht unterbrochen werden.

Hinweis

Diese Methoden ermöglichen die Verwaltung des Lebenszyklus und der Ausführung von Threads in Java und bieten Flexibilität sowie Kontrolle über Multithread-Anwendungen. In den folgenden Kapiteln werden wir diese Methoden näher betrachten.

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

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Suggested prompts:

Can you explain the difference between extending the Thread class and implementing the Runnable interface?

How does the start() method work in Java threads?

What happens if I call the run() method directly instead of start()?

Awesome!

Completion rate improved to 3.33

Swipe um das Menü anzuzeigen

Deklaration eines Threads in Java

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

Main.java


              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 kann das Runnable-Interface implementiert, eine run()-Methode bereitgestellt und an den Konstruktor der Thread-Klasse übergeben werden.

Main.java


              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 kann die Thread-Klasse geerbt und die run()-Methode überschrieben werden.

Main.java


              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

Es ist ebenfalls möglich, das Runnable-Interface zu implementieren und darin die Methode run() zu überschreiben:

Main.java


              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

Unterschied zwischen Thread und Runnable

Verfügbare Methoden für Threads in Java

Main.java


              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());
    }
}

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

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
}

Main.java


              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();
    }
}

Ohne einen Ausnahmebehandler für InterruptedException im Thread würde der Thread nicht unterbrochen werden.

Hinweis

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