Top 40 vragen en antwoorden over Java Multithreading-interviews – editie 2026

Voorbereiding op een Java-multithreading-interview vereist een diepgaand begrip van concurrency-concepten en praktische ervaring. Hieronder vindt u 40 zorgvuldig opgestelde vragen en antwoorden van experts die alles bestrijken, van basisdefinities tot geavanceerde onderwerpen zoals virtuele threads en gestructureerde gelijktijdigheid.

👉 Gratis pdf-download:vragen en antwoorden over Java Multithreading-interviews

1) Wat is multithreading in Java en waarom wordt het gebruikt?

Met multithreading kan een Java-toepassing meerdere threads tegelijkertijd uitvoeren, waardoor het CPU-gebruik wordt gemaximaliseerd en de responsiviteit wordt verbeterd. Het is vooral waardevol voor I/O-gebonden taken, grootschalige berekeningen en GUI-updates waarbij de ene thread kan blokkeren terwijl de andere doorgaat met verwerken.

Voordelen

• Hoger CPU-gebruik
• Verminderde latentie voor onafhankelijke bewerkingen
• Verbeterde reactiesnelheid van de gebruikersinterface

Voorbeeld :Een webserver kan tientallen clientverzoeken tegelijkertijd verwerken door elk verzoek aan een afzonderlijke thread toe te wijzen, waardoor blokkering van I/O-bewerkingen wordt vermeden.

2) Leg de levenscyclus van een thread in Java uit.

Java-threads doorlopen de volgende statussen:

Wanneer t.start() wordt aangeroepen, verplaatst de thread zich van Nieuw naar Uitvoerbaar .

3) Wat is het verschil tussen een proces en een thread?

Een browserproces kan bijvoorbeeld meerdere threads bevatten voor weergave, netwerken en gebruikersinteractie.

4) Hoe werkt synchronisatie in Java?

Synchronisatie garandeert dat slechts één thread tegelijk toegang heeft tot een gedeelde bron, waardoor raceomstandigheden en gegevenscorruptie worden voorkomen. De synchronized trefwoord vergrendelt een hele methode of een specifiek blok.

1. Gesynchroniseerde methode – vergrendelt de monitor van de methode.
2. Gesynchroniseerd blok – vergrendelt een gekozen object.

synchronized void increment() {
    count++;
}

5) Wat zijn de verschillende manieren om een thread in Java te maken?

1. Thread wordt uitgebreid

   class MyThread extends Thread {
       public void run() { System.out.println("Thread running"); }
   }
   new MyThread().start();

2. Implementatie van Runnable

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

3. Oproepbaar en toekomstig (modern) – retourneert een waarde en kan gecontroleerde uitzonderingen genereren.

   Callable task = () -> 42;
   Future result = executor.submit(task);
   System.out.println(result.get());

6) Wat is het verschil tussen start() en run() ?

Bellen naar t.start() lanceert een nieuwe draad; t.run() gedraagt zich als elke andere methode.

7) Leg het concept van draadveiligheid uit en hoe je dit kunt bereiken.

Thread-veiligheid zorgt ervoor dat gelijktijdige toegang tot gedeelde gegevens de status niet beschadigt. Dit kan worden bereikt via:

• synchronized blokken of methoden
• volatile variabelen
• Expliciete vergrendelingen (bijvoorbeeld ReentrantLock , ReadWriteLock )
• Thread-safe collecties (ConcurrentHashMap , CopyOnWriteArrayList )
• Atomische klassen (AtomicInteger , AtomicBoolean )

AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();

8) Wat is het verschil tussen wait() , sleep() , en yield() ?

Gebruik wait() voor communicatie tussen threads; gebruik sleep() om een gesprek te onderbreken.

9) Hoe verbetert het Executor Framework het threadbeheer?

Het raamwerk koppelt het indienen van taken los van het maken van threads, waardoor efficiënt threadpoolen en hergebruik van bronnen mogelijk wordt. Het maakt deel uit van java.util.concurrent en aanbiedingen:

• Hergebruik van threads voor minder overhead
• Flexibele pooltypen (vast, in cache, enkelvoudig, gepland, werkstelen)
• Gracieuze afsluitmechanismen

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> System.out.println("Task executed"));
executor.shutdown();

10) Wat zijn de verschillende soorten threadpools die beschikbaar zijn in Java?

11) Wat is een impasse in Java en hoe kan deze worden voorkomen?

Een deadlock treedt op wanneer twee of meer threads voor onbepaalde tijd op elkaar wachten om de vergrendelingen op te heffen. Het komt meestal voort uit een inconsistente vergrendelingsvolgorde.

synchronized (A) {
    synchronized (B) { /*...*/ }
}

synchronized (B) {
    synchronized (A) { /*...*/ }
}

Preventiestrategieën:

1. Verkrijg sloten in een consistente mondiale volgorde.
2. Gebruik tryLock() met een time-out.
3. Vermijd geneste sloten indien mogelijk.
4. Geef de voorkeur aan gelijktijdigheidshulpprogramma's op hoog niveau boven handmatige vergrendelingen.

12) Verschil tussen synchronized en ReentrantLock .

ReentrantLock lock = new ReentrantLock();
if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try { /* critical section */ } finally { lock.unlock(); }
}

13) Verschil tussen volatile en synchronized .

volatile boolean running = true;

synchronized void increment() { count++; }

14) Leg ThreadLocal in Java uit.

ThreadLocal biedt threadspecifieke gegevens, waardoor de noodzaak voor een gedeelde veranderlijke status wordt geëlimineerd. Elke thread heeft toegang tot zijn eigen geïsoleerde kopie.

ThreadLocal counter = ThreadLocal.withInitial(() -> 0);
counter.set(counter.get() + 1);

• Voorkomt gegevensbeschadiging
• Handig voor context per thread (bijvoorbeeld sessie-ID's)
• Moet remove() aanroepen in threadpools om geheugenlekken te voorkomen

15) Wat zijn atomaire klassen in Java en waarom worden ze gebruikt?

Atomaire klassen (bijvoorbeeld AtomicInteger , AtomicBoolean , AtomicReference ) voer lock-free, thread-safe bewerkingen uit met behulp van CAS (Compare-And-Swap). Ze bieden een hogere doorvoer voor eenvoudige updates vergeleken met gesynchroniseerde blokken.

AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();

16) Wat is een semafoor en hoe verschilt deze van een slot?

Semaphore sem = new Semaphore(3);
sem.acquire();
// use resource
sem.release();

17) Leg het Fork/Join-framework uit.

Het is geïntroduceerd in Java 7 en maakt parallelle uitvoering mogelijk van recursief gesplitste taken met behulp van een algoritme voor het stelen van werk. Inactieve threads stelen werk van drukke threads, waardoor het CPU-gebruik wordt gemaximaliseerd.

class SumTask extends RecursiveTask {
    protected Integer compute() {
        if (end - start <= threshold) return computeDirectly();
        int mid = (start + end) / 2;
        SumTask left = new SumTask(start, mid);
        SumTask right = new SumTask(mid, end);
        left.fork();
        return right.compute() + left.join();
    }
}

18) Hoe verbetert CompletableFuture asynchrone programmering?

CompletableFuture maakt niet-blokkerende, composeerbare asynchrone bewerkingen mogelijk, waardoor de callback-hel wordt geëlimineerd en chaining, uitzonderingsafhandeling en parallelle compositie worden ondersteund.

CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(str -> str + " World")
    .thenAccept(System.out::println);

19) Wat is een daemonthread?

Daemon-threads draaien op de achtergrond en leveren diensten zoals garbagecollection of timertaken. De JVM beëindigt automatisch alle daemon-threads als er geen gebruikersthreads meer zijn.

Thread daemon = new Thread(() -> System.out.println("Daemon running"));
daemon.setDaemon(true);
daemon.start();

20) Best practices voor multithreading in Java.

1. Geef de voorkeur aan gelijktijdigheidshulpprogramma's op hoog niveau (ExecutorService, BlockingQueue).
2. Vermijd gedeelde veranderlijke status; voorstander van onveranderlijkheid.
3. Gebruik gelijktijdige verzamelingen via gesynchroniseerde wrappers.
4. Ga met onderbrekingen om en herstel de onderbrekingsvlag.
5. Sluit uitvoerders netjes af met shutdown() of shutdownNow() .
6. Minimaliseer het synchronisatiebereik om conflicten te verminderen.
7. Profiel vóór optimaliseren; tools zoals JFR en asynchrone profiler helpen bij het identificeren van hotspots.

21) Wat is het Java Memory Model (JMM) en waarom is het belangrijk?

De JMM definieert hoe threads via het geheugen samenwerken, waardoor zichtbaarheid, ordening en atomiciteit worden gegarandeerd. Het legt de 'gebeurt vóór'-relatie vast, die van cruciaal belang is voor het schrijven van correcte gelijktijdige code.

• Zichtbaarheid:wijzigingen in één thread moeten door anderen worden gezien.
• Volgorde:acties worden geordend om de consistentie te behouden.
• Atomiciteit:Bepaalde operaties zijn ondeelbaar.

22) Verschil tussen ConcurrentHashMap en gesynchroniseerdeMap.

23) Impasses detecteren en debuggen.

1. Threaddumps via jstack <pid> impasses onthullen.
2. VisualVM of JConsole bieden realtime threadmonitoring.
3. Programmatische detectie met ThreadMXBean.findDeadlockedThreads() .

24) Parallelle streams versus expliciete threads.

Parallelle streams maken intern gebruik van het Fork/Join-framework, dat een API op hoog niveau biedt voor gegevensverwerking. Expliciete threads vereisen handmatig beheer, maar bieden een fijnmazige controle.

25) CountDownLatch, CyclicBarrier en Phaser.

CountDownLatch latch = new CountDownLatch(3);
for (...) new Thread(() -> { /* work */ latch.countDown(); }).start();
latch.await();

26) Verschil tussen opvraagbaar en uitvoerbaar.

Callable task = () -> 42;
Future result = executor.submit(task);
System.out.println(result.get());

27) BlockingQueue voor producent-consument.

BlockingQueue biedt thread-safe blokkeringsbewerkingen die het producent-consument-patroon vereenvoudigen.

BlockingQueue queue = new ArrayBlockingQueue<>(10);
new Thread(() -> queue.put(1)).start(); // Producer
new Thread(() -> System.out.println(queue.take())).start(); // Consumer

• Elimineert handleiding wait() /notify() .
• Ondersteunt begrensde en onbegrensde implementaties.

28) Uithongering en livelock.

Uithongering treedt op wanneer threads met een lage prioriteit nooit CPU-tijd ontvangen. Livelock vindt plaats wanneer threads voortdurend van status veranderen, maar geen vooruitgang boeken. Mitigatie omvat eerlijke sloten, het vermijden van drukke wachtrijen en een goede planning.

29) Verbetering van de prestaties van multithreaded applicaties.

1. Gebruik threadpools.
2. Verklein het synchronisatiebereik.
3. Maak gebruik van gelijktijdige datastructuren.
4. Geef de voorkeur aan onveranderlijke objecten.
5. Vermijd vals delen.
6. Stem het aantal threads af op CPU-kernen.
7. Gebruik asynchrone I/O voor het blokkeren van bewerkingen.

30) Multithreading-scenario in de echte wereld.

In een betalingsgateway werd de gelijktijdige transactieverwerking geoptimaliseerd door:

1. ExecutorService voor werkthreads.
2. ConcurrentHashMap voor transactiestatus.
3. ReentrantLock voor vergrendeling op accountniveau.
4. CountDownLatch voor batchsynchronisatie.
5. CompletableFuture voor asynchrone reacties.

Resultaat:35% doorvoerwinst en 40% latentiereductie.

31) Virtuele threads in Java.

Virtuele threads, geïntroduceerd in Java 21, zijn lichtgewicht threads die worden beheerd door de JVM, waardoor miljoenen gelijktijdige taken mogelijk zijn met minimale overhead.

Thread.startVirtualThread(() -> System.out.println("Virtual thread running"));

32) Gestructureerde gelijktijdigheid.

Gestructureerde gelijktijdigheid, een preview in Java 21, behandelt meerdere gelijktijdige taken als één geheel, zodat ze samen worden gestart, beheerd en beëindigd. Het elimineert weesthreads en vereenvoudigt de verspreiding van fouten.

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future user = scope.fork(() -> findUser());
    Future order = scope.fork(() -> fetchOrderCount());
    scope.join();
    scope.throwIfFailed();
    System.out.println(user.resultNow() + " has " + order.resultNow() + " orders.");
}

33) Reactieve streams in Java.

Reactive Streams bieden een niet-blokkerend, tegendrukbewust model voor het verwerken van datastromen en vormen de basis voor raamwerken als Project Reactor, RxJava en Spring WebFlux.

• Publisher – produceert gegevens.
• Subscriber – verbruikt gegevens.
• Subscription – controleert de stroom.
• Processor – zowel uitgever als abonnee.

Flow.Publisher publisher = subscriber -> subscriber.onNext(42);

34) Correct omgaan met draadonderbrekingen.

Controleer altijd Thread.interrupted() in loops, ruim bronnen op en behoud de interruptstatus na het vangen van InterruptedException .

while (!Thread.currentThread().isInterrupted()) {
    try { Thread.sleep(1000); }
    catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // restore flag
        break;
    }
}

35) Parallellisme versus gelijktijdigheid.

Concurrency beheert meerdere taken door de uitvoering te interleaven, terwijl parallellisme taken gelijktijdig uitvoert over meerdere CPU-kernen.

36) Tools en technieken voor threadprofilering.

ThreadMXBean bean = ManagementFactory.getThreadMXBean();
System.out.println(bean.getThreadCount());

37) Veel voorkomende prestatieknelpunten.

1. Overmatige vergrendelingsconflicten.
2. Onjuist delen van variabelen.
3. Overhead voor contextwisseling.
4. Onjuiste synchronisatie.
5. Overmatig gebruik van vluchtige variabelen.

Optimalisaties omvatten fijnmazige vergrendeling, vergrendelingsvrije structuren, het minimaliseren van threadcreatie en het gebruik van thread-lokale opslag.

38) Algoritmen zonder vergrendeling, wachtvrij en obstakelvrij.

AtomicInteger-bewerkingen zijn lock-free; blokkerende wachtrijen gebruiken vergrendelingen.

39) ForkJoinPool-interne onderdelen.

Elke arbeider onderhoudt zijn eigen deque; inactieve werknemers stelen taken van anderen, waardoor de strijd afneemt en de doorvoer verbetert.

ForkJoinPool pool = new ForkJoinPool();
pool.submit(() -> IntStream.range(0, 100).parallel().forEach(System.out::println));

40) Een zeer gelijktijdig systeem ontwerpen voor miljoenen verzoeken.

1. Virtuele discussies voor lichtgewicht afhandeling van verzoeken.
2. Reactieve streams voor asynchrone I/O.
3. Gestructureerde gelijktijdigheid voor voorspelbare taaklevenscycli.
4. Krachtige caches (ConcurrentHashMap, Caffeine).
5. Thread-safe wachtrijen (Disruptor, BlockingQueue).
6. Monitoring met JFR en JMC.
7. CompletableFuture voor asynchrone workflows.

Resultaat:Realiseer miljoenen gelijktijdige verbindingen met minimale blokkering en optimaal gebruik van bronnen.

🔍 Belangrijkste Java-multithreading-interviewvragen met scenario's uit de praktijk en strategische reacties

Hieronder staan tien realistische vragen, wat interviewers verwachten en gepolijste voorbeeldantwoorden.

1) Verschil tussen een proces en een thread in Java?

De kandidaat moet de basisbeginselen van het besturingssysteem en JVM, het geheugengebruik en de uitvoeringsstroom uitleggen. Een browserproces bevat bijvoorbeeld meerdere threads voor weergave, netwerken en gebruikersinvoer.

2) Doel van de synchronized trefwoord?

Legt gelijktijdigheidscontrole, intrinsieke vergrendelingen en draadveiligheid uit. Het zorgt ervoor dat slechts één thread tegelijk toegang heeft tot een kritieke sectie.

3) Uitdagend multithreading-probleem onder ogen gezien en opgelost?

Beschrijf een impassescenario, hoe je dit hebt geïdentificeerd via threaddumps en hebt opgelost door een consistente lock-order af te dwingen.

4) Java-geheugenmodel en zichtbaarheid?

Beschrijf relaties die voorafgaan aan de gebeurtenissen, volatile , en synchronisatieconstructies die zichtbaarheid en ordening garanderen.

5) Verschil tussen wait() , notify() , en notifyAll() ?

Leg de communicatie tussen threads uit en controleer de mechanismen.

6) Een multithreaded applicatie optimaliseren?

Identificeer het slotconflict en vervang synchronized met ConcurrentHashMap , en meetbare doorvoerwinsten laten zien.

7) Een gedeelde datastructuur veilig bijwerken?

Gebruik thread-safe collecties of expliciete vergrendeling met ReentrantLock voor gedetailleerde controle.

8) Rol van ExecutorService ?

Beheert een verzameling werkthreads, vermindert de overhead en vereenvoudigt het levenscyclusbeheer.

9) Problemen oplossen met een raceconditie?

Reproduceer onder belasting, verbeter de logboekregistratie en corrigeer dit door de juiste synchronisatie toe te voegen.

10) Een multithreading-oplossing ontwerpen met verschillende prioriteiten?

Gebruik een prioriteitswachtrij met ThreadPoolExecutor en aangepaste vergelijker voor taken met een hogere prioriteit.

• De geschiedenis van de metaalproductie

  Metaalproductie is een integraal onderdeel van de moderne samenleving. Sloten, stoelen, gebruiksvoorwerpen, verlichtingsarmaturen, autos en nog veel meer van de producten en gereedschappen die we dagelijks gebruiken, worden mogelijk gemaakt door metaalbewerking. Metaalbewerking heeft door de geschi

• Best practices voor het smeren van API-lagerhuizen voor centrifugaalpompen

  Steeds meer fabrieken hebben doelen gericht op het verlengen van de gemiddelde tijd tussen reparaties (MTBR) voor hun roterende apparatuur, waaronder centrifugaalpompen voor gebruik in de aardolie-, petrochemische en aardgasindustrie. Het maximaliseren van de smeringseffectiviteit in API-procespompe

• Hoe de productiecapaciteit van de productie te vergroten?

  De meeste bedrijven hechten veel waarde aan het vermogen om de productiecapaciteit te vergroten. En het is vooral waardevol om dit te doen als extra apparatuurkosten kunnen worden vermeden. De aard van productie is immers om goederen te produceren, en moderne operaties worden hierin alleen maar effi

• Nieuwsoverzicht over robotica en automatisering:OnRobot werkt software bij, drones vliegen door diepe mijnen, Toyota werkt samen met Ridecell en nog veel meer...

  Robotic and Automation News Review maandag 24 augustus 2020 Dit is een nieuwe, wekelijkse column waarin in korte vorm al het meest interessante nieuws uit de robotica- en automatiseringsindustrie van de afgelopen zeven dagen wordt samengevat. Meestal proberen we de recensie op vrijdag te public