Java -threads
Java-threads
Met Threads kan een programma efficiënter werken door meerdere dingen tegelijk te doen.
Threads kunnen worden gebruikt om ingewikkelde taken op de achtergrond uit te voeren zonder het hoofdprogramma te onderbreken.
Een discussielijn maken
Er zijn twee manieren om een draad te maken.
Het kan worden gemaakt door de klasse uit te breiden Threaden de methode ervan te overschrijven run()
:
Syntaxis uitbreiden
public class Main extends Thread { public void run() { System.out.println("This code is running in a thread");}}
Een andere manier om een thread te maken, is door de Runnableinterface te implementeren:
Syntaxis implementeren
public class Main implements Runnable {
public void run() {
System.out.println("This code is running in a thread");
}
}Lopende discussies
Als de klasse de klasse uitbreidt Thread, kan de thread worden uitgevoerd door een instantie van de klasse te maken en de start()methode ervan aan te roepen:
Voorbeeld uitbreiden
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");
}
}
Als de klasse de Runnableinterface implementeert, kan de thread worden uitgevoerd door een instantie van de klasse door te geven aan Threadde constructor van een object en vervolgens de methode van de thread aan te roepen
start():
Voorbeeld implementeren
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");
}
}
Verschillen tussen threads "uitbreiden" en "implementeren"
Het grote verschil is dat wanneer een klasse de Thread-klasse uitbreidt, je geen andere klasse kunt uitbreiden, maar door de Runnable-interface te implementeren, is het ook mogelijk om uit te breiden vanuit een andere klasse, zoals: class MyClass extends OtherClass implements Runnable.
Gelijktijdigheidsproblemen
Omdat threads tegelijkertijd met andere delen van het programma worden uitgevoerd, is er geen manier om te weten in welke volgorde de code zal worden uitgevoerd. Wanneer de threads en het hoofdprogramma dezelfde variabelen lezen en schrijven, zijn de waarden onvoorspelbaar. De problemen die hieruit voortvloeien worden concurrency problemen genoemd.
Voorbeeld
Een codevoorbeeld waarbij de waarde van het variabele bedrag onvoorspelbaar is:
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++;}}
Om gelijktijdigheidsproblemen te voorkomen, is het het beste om zo min mogelijk attributen tussen threads te delen. Als attributen moeten worden gedeeld, is een mogelijke oplossing om de isAlive()
methode van de thread te gebruiken om te controleren of de thread klaar is met lopen voordat attributen worden gebruikt die de thread kan wijzigen.
Voorbeeld
Gebruik isAlive()om gelijktijdigheidsproblemen te voorkomen:
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++;}}