Java Multithreading onder de knie: Efficiënt gelijktijdig programmeren

Wat is multithreading?

Java is een multi-threaded programmeertaal, wat betekent dat je programma's kunt schrijven die meerdere taken gelijktijdig uitvoeren. Een thread is een lichte uitvoeringslijn binnen een proces. Door taken te verdelen over threads maak je optimaal gebruik van multicore-processors.

Levenscyclus van een thread

Een thread doorloopt de volgende stadia:

• New (Nieuw) – De thread is aangemaakt maar nog niet gestart.
• Runnable (Uitvoerbaar) – Na aanroep van start() is de thread klaar om te draaien.
• Waiting (Wachtend) – De thread wacht op een signaal van een andere thread (bijv. wait(), join()).
• Timed Waiting (Getimed wachtend) – Wacht voor een bepaalde tijd (sleep(), wait(timeout)).
• Terminated (Beëindigd) – De run()-methode is voltooid of er is een onvangbare exception opgetreden.

Thread-prioriteiten

Elke thread heeft een prioriteit (1–10, standaard 5). Hogere prioriteit betekent meer kans op CPU-tijd, maar de JVM geeft geen garanties over uitvoervolgorde.

Een thread maken via Runnable

De aanbevolen manier: implementeer Runnable en geef het door aan een Thread-object.

Stappen

1. Implementeer public void run() met je logica.
2. Maak een Thread aan: new Thread(runnable, "naam").
3. Roep start() aan (niet run() direct!).

Voorbeeld

class RunnableDemo implements Runnable {
    private Thread t;
    private String threadName;

    RunnableDemo(String name) {
        threadName = name;
        System.out.println("Aanmaken " + threadName);
    }

    public void run() {
        System.out.println("Draaien " + threadName);
        try {
            for (int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                Thread.sleep(50);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread " + threadName + " onderbroken.");
        }
        System.out.println("Thread " + threadName + " stopt.");
    }

    public void start() {
        System.out.println("Starten " + threadName);
        if (t == null) {
            t = new Thread(this, threadName);
            t.start();
        }
    }
}

public class TestThread {
    public static void main(String[] args) {
        RunnableDemo R1 = new RunnableDemo("Thread-1");
        R1.start();
        RunnableDemo R2 = new RunnableDemo("Thread-2");
        R2.start();
    }
}

Een thread maken door Thread te extenten

Alternatief: maak een subklasse van Thread en overschrijf run(). Dit geeft meer controle maar beperkt overerving (Java ondersteunt geen multiple inheritance).

Voorbeeld

class ThreadDemo extends Thread {
    private String threadName;

    ThreadDemo(String name) {
        threadName = name;
        System.out.println("Aanmaken " + threadName);
    }

    public void run() {
        System.out.println("Draaien " + threadName);
        try {
            for (int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);
                Thread.sleep(50);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread " + threadName + " onderbroken.");
        }
        System.out.println("Thread " + threadName + " stopt.");
    }
}

public class TestThread {
    public static void main(String[] args) {
        ThreadDemo T1 = new ThreadDemo("Thread-1");
        T1.start();
        ThreadDemo T2 = new ThreadDemo("Thread-2");
        T2.start();
    }
}

Belangrijke Thread-methoden

Statische methoden

Belangrijke concepten voor gevorderden

• Thread-synchronisatie (synchronized, locks)
• Inter-thread communicatie (wait(), notify(), notifyAll())
• Deadlock-voorkoming
• Thread-pools en ExecutorService (moderne API)