Antwoord.

Geschiedenis van de vraag:

Java ondersteunt multithreading vanaf het begin. Threads maken het mogelijk om verschillende taken parallel uit te voeren en efficiënt gebruik te maken van multi-core processors. De JVM biedt een abstractielaag bovenop de threads van het besturingssysteem.

Probleem:

Het maken, beheren en beëindigen van threads vereist een duidelijke begrip van hun levenscyclus, synchronisatie en mogelijke race-omstandigheden. Onoordeelkundig gebruik van threads kan leiden tot deadlocks, onjuist toegang tot bronnen en complexe foutlogs.

Oplossing:

In Java kunnen threads worden gemaakt door het uitbreiden van de klasse Thread of het implementeren van de interface Runnable, evenals door moderne middelen zoals ExecutorService. Het is belangrijk om threads correct te beëindigen, hun levenscyclus te beheren en toegang tot gedeelde gegevens te synchroniseren.

Voorbeeld van het maken en beëindigen van een thread:

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start(); // start de thread
        try {
            t.join(); // wacht op beëindiging
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Belangrijke kenmerken:

Threads moeten worden gestart met de methode start(), en niet run() (anders is er geen echte paralleliteit)
Voor een correcte beëindiging is het belangrijk join() te gebruiken
Een beëindigde thread kan niet opnieuw worden gestart: een nieuwe start gooit IllegalThreadStateException

Vragen met een valkuil.

Kan een thread opnieuw worden gestart nadat deze is beëindigd?

Nee. Na beëindiging wordt de thread als "dood" beschouwd, een herhaald aanroep van start() leidt tot IllegalThreadStateException.

Wat is het verschil tussen het aanroepen van t.run() en t.start()?

t.run() roept gewoon de run-methode aan in de huidige thread zonder een nieuwe uitvoeringsthread te creëren. Alleen t.start() creëert een aparte OS-thread.

Wat gebeurt er als een thread wordt beëindigd met een onopgevangen uitzondering?

Als een onopgevangen uitzondering wordt gegooid, zal de thread abnormaal eindigen, zijn stacktrace zal in de error stream worden weergegeven, andere threads worden niet beïnvloed.

Typische fouten en antipatterns

Aanroep van run() in plaats van start()
On tijdig beëindigen van een thread (bijvoorbeeld gebrek aan afhandeling van InterruptedException)
Een thread oneindig maken zonder beëindigingsvoorwaarden

Voorbeeld uit het leven

Negatieve case

Een programmeur start een thread met de run() methode, denkend dat deze parallel draait met main, maar in werkelijkheid wordt alles sequentieel uitgevoerd.

Voordelen:

De logica van het programma werkt correct

Nadelen:

Geen parallelisme, gemiste optimalisatie in uitvoeringstijd

Positieve case

Correct gebruik van start(), correcte afhandeling van uitzonderingen, toepassing van join() om te wachten op de voltooiing van threads.