Threads in Java
Stel je bijvoorbeeld voor dat je programma een hoofdthread heeft die verantwoordelijk is voor het weergeven van de gebruikersinterface. Tegelijkertijd kun je een extra thread aanmaken om gegevens te laden van het netwerk of complexe berekeningen uit te voeren. Dit zorgt ervoor dat het programma responsiever en efficiënter wordt.
Een thread declareren in Java
Met de Thread: klasse kun je een subklasse van de Thread-klasse maken en de run() -methode overschrijven, die de code bevat die in de nieuwe thread wordt uitgevoerd.
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();
Het gebruik van de Runnable-interface
Met de Runnable interface kun je de Runnable interface implementeren, een run()-methode definiëren en deze doorgeven aan de constructor van de Thread-klasse.
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();
Thread-klasse overerving
Als alternatief kan de Thread-klasse worden geërfd en de run()-methode worden overschreven.
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 } }
Implementatie van de Runnable-interface
Het is ook mogelijk om de Runnable-interface te implementeren en daarin de run()-methode te definiëren:
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 } }
De run() methode in een Java thread maakt het mogelijk om code uit te voeren in een aparte thread, waaronder taken zoals werken met data, berekeningen, het downloaden van bestanden, en het verzenden of ontvangen van data via het netwerk.
Verschil tussen Thread en Runnable
In Java is een Thread een speciaal kanaal dat gelijktijdige uitvoering van taken mogelijk maakt, waardoor je programma bewerkingen kan uitvoeren in een aparte thread, zoals berekeningen of langdurige processen zoals het laden van data.
De Runnable interface, met zijn enkele run() methode, definieert een taak die door een thread uitgevoerd moet worden. Je kunt een Runnable implementatie meegeven aan een Thread constructor om de taak in een nieuwe thread uit te voeren. Deze methode helpt bij het efficiënt beheren en uitvoeren van parallelle taken.
Beschikbare methoden voor threads in Java
Een thread starten met de start() methode geeft aan dat de code in een nieuwe thread moet worden uitgevoerd. Dit betekent dat de hoofdthread doorgaat met het uitvoeren van zijn eigen code en niet wacht tot de nieuw gestarte thread is voltooid.
Main.java
1234567891011121314151617181920212223242526package 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()); } }
Er is ook een methode waarmee de hoofdthread kan wachten op de uitvoering van de thread die hij heeft gestart, door gebruik te maken van de join() methode. Deze methode wacht totdat de thread volledig is uitgevoerd. Je kunt controleren of de thread momenteel actief is met de isAlive() methode.
De code Thread.sleep(5000) pauzeert de thread voor 5000 milliseconden (5 seconden).
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
}
In het voorbeeld was de thread actief voordat join() werd aangeroepen. Na het aanroepen van join() is dat niet meer het geval, omdat join() betekent dat we op dat punt wachten tot de thread zijn uitvoering heeft voltooid.
Als we een thread willen stoppen, kunnen we de interrupt() methode gebruiken. Om dit te laten werken, moeten we echter controleren of de thread die we stoppen onderbroken is.
Main.java
123456789101112131415161718192021222324252627282930313233package 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(); } }
Dit voorbeeld maakt een thread aan die een taak in een lus uitvoert totdat deze onderbroken wordt. Wanneer de thread wordt onderbroken tijdens het slapen, wordt er een exceptie opgegooid, afgehandeld door de interrupt-vlag te zetten, en vervolgens beëindigt de thread.
Zonder een InterruptedException-exceptiehandler in de thread zou de thread niet onderbroken worden.
Deze methoden stellen u in staat het levenscyclusbeheer en de uitvoering van threads in Java te beheren, wat flexibiliteit en controle biedt over multithreaded applicaties. In de volgende hoofdstukken gaan we dieper in op deze methoden.
1. Wat is een thread in Java?
2. Wat is het verschil tussen de Thread-klasse en de Runnable-interface in Java?
Bedankt voor je feedback!
Vraag AI
Vraag AI
Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.
Awesome!
Completion rate improved to 3.33Threads in Java
Veeg om het menu te tonen
Stel je bijvoorbeeld voor dat je programma een hoofdthread heeft die verantwoordelijk is voor het weergeven van de gebruikersinterface. Tegelijkertijd kun je een extra thread aanmaken om gegevens te laden van het netwerk of complexe berekeningen uit te voeren. Dit zorgt ervoor dat het programma responsiever en efficiënter wordt.
Een thread declareren in Java
Met de Thread: klasse kun je een subklasse van de Thread-klasse maken en de run() -methode overschrijven, die de code bevat die in de nieuwe thread wordt uitgevoerd.
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();
Het gebruik van de Runnable-interface
Met de Runnable interface kun je de Runnable interface implementeren, een run()-methode definiëren en deze doorgeven aan de constructor van de Thread-klasse.
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();
Thread-klasse overerving
Als alternatief kan de Thread-klasse worden geërfd en de run()-methode worden overschreven.
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 } }
Implementatie van de Runnable-interface
Het is ook mogelijk om de Runnable-interface te implementeren en daarin de run()-methode te definiëren:
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 } }
De run() methode in een Java thread maakt het mogelijk om code uit te voeren in een aparte thread, waaronder taken zoals werken met data, berekeningen, het downloaden van bestanden, en het verzenden of ontvangen van data via het netwerk.
Verschil tussen Thread en Runnable
In Java is een Thread een speciaal kanaal dat gelijktijdige uitvoering van taken mogelijk maakt, waardoor je programma bewerkingen kan uitvoeren in een aparte thread, zoals berekeningen of langdurige processen zoals het laden van data.
De Runnable interface, met zijn enkele run() methode, definieert een taak die door een thread uitgevoerd moet worden. Je kunt een Runnable implementatie meegeven aan een Thread constructor om de taak in een nieuwe thread uit te voeren. Deze methode helpt bij het efficiënt beheren en uitvoeren van parallelle taken.
Beschikbare methoden voor threads in Java
Een thread starten met de start() methode geeft aan dat de code in een nieuwe thread moet worden uitgevoerd. Dit betekent dat de hoofdthread doorgaat met het uitvoeren van zijn eigen code en niet wacht tot de nieuw gestarte thread is voltooid.
Main.java
1234567891011121314151617181920212223242526package 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()); } }
Er is ook een methode waarmee de hoofdthread kan wachten op de uitvoering van de thread die hij heeft gestart, door gebruik te maken van de join() methode. Deze methode wacht totdat de thread volledig is uitgevoerd. Je kunt controleren of de thread momenteel actief is met de isAlive() methode.
De code Thread.sleep(5000) pauzeert de thread voor 5000 milliseconden (5 seconden).
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
}
In het voorbeeld was de thread actief voordat join() werd aangeroepen. Na het aanroepen van join() is dat niet meer het geval, omdat join() betekent dat we op dat punt wachten tot de thread zijn uitvoering heeft voltooid.
Als we een thread willen stoppen, kunnen we de interrupt() methode gebruiken. Om dit te laten werken, moeten we echter controleren of de thread die we stoppen onderbroken is.
Main.java
123456789101112131415161718192021222324252627282930313233package 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(); } }
Dit voorbeeld maakt een thread aan die een taak in een lus uitvoert totdat deze onderbroken wordt. Wanneer de thread wordt onderbroken tijdens het slapen, wordt er een exceptie opgegooid, afgehandeld door de interrupt-vlag te zetten, en vervolgens beëindigt de thread.
Zonder een InterruptedException-exceptiehandler in de thread zou de thread niet onderbroken worden.
Deze methoden stellen u in staat het levenscyclusbeheer en de uitvoering van threads in Java te beheren, wat flexibiliteit en controle biedt over multithreaded applicaties. In de volgende hoofdstukken gaan we dieper in op deze methoden.
1. Wat is een thread in Java?
2. Wat is het verschil tussen de Thread-klasse en de Runnable-interface in Java?
Bedankt voor je feedback!
