Multithreading in Java – Alles wat je MOET weten

Wanneer we een real-world toepassing draaien, gebruiken we goede processoren voor snellere uitvoering. Maar alleen de snelheid van de processor kan niet zorgen dat je toepassing snel draait. Een van de geweldige manieren om een efficiënte prestatietoepassing te creëren, is het gebruik van multithreading.

Wat is Multithreading?

Multithreading is een programmeerconcept waarbij de toepassing een kleine eenheid van taken kan creëren om parallel uit te voeren. Als je aan een computer werkt, draait deze meerdere toepassingen en wijst verwerkingskracht aan hen toe. Een eenvoudig programma wordt sequentieel uitgevoerd en de code-instructies worden één voor één uitgevoerd. Dit is een single-threaded toepassing. Maar als de programmeertaal het maken van meerdere threads ondersteunt en deze naar het besturingssysteem doorgeeft om parallel uit te voeren, wordt het multithreading genoemd.

Multithreading versus Multiprocessing

Als we het hebben over multithreading, maakt het niet uit of de machine een 2-core processor of een 16-core processor heeft. Onze taak is het creëren van een multithreaded toepassing en de OS het toewijzings- en uitvoeringsgedeelte laten afhandelen. Kortom, multithreading heeft niets te maken met multiprocessing.

Hoe ondersteunt Java multithreading?

Java biedt uitstekende ondersteuning voor multithreaded toepassingen. Java ondersteunt multithreading via de Thread-klasse. Java Thread stelt ons in staat om een lichtgewicht proces te creëren dat enkele taken uitvoert. We kunnen meerdere threads in ons programma maken en ze starten. De Java-runtime zorgt voor het genereren van machine-instructies en werkt samen met het besturingssysteem om ze parallel uit te voeren.

Wat zijn de verschillende typen threads?

Er zijn twee soorten threads in een toepassing – gebruikersthread en daemonthread. Wanneer we een toepassing starten, is de main de eerste gebruikersthread die wordt gemaakt. We kunnen zowel gebruikersthreads als daemonthreads maken. Wanneer alle gebruikersthreads zijn uitgevoerd, beëindigt de JVM het programma.

Wat is Thread Prioriteit?

Wanneer we een thread creëren, kunnen we de prioriteit ervan toewijzen. We kunnen verschillende prioriteiten instellen voor verschillende threads, maar dit garandeert niet dat een thread met een hogere prioriteit eerder wordt uitgevoerd dan een thread met een lagere prioriteit. De threadplanner is een onderdeel van de implementatie van het besturingssysteem en wanneer een thread wordt gestart, wordt de uitvoering ervan gecontroleerd door de threadplanner, en de JVM heeft geen controle over de uitvoering ervan.

Hoe maken we een thread in Java?

We kunnen threads maken door ofwel de interface Runnable te implementeren of door de klasse Thread uit te breiden.

Thread t = new Thread(new Runnable(){
    @Override
    public void run() {
    }
});

Hierboven staat een beknopte verklaring om een nieuwe thread te maken. Hier creëren we een Runnable als een anonieme klasse. Als je bekend bent met lambda-uitdrukkingen, kunnen we een thread maken met veel kortere code.

Runnable runnable = () -> System.out.println("Hello");

Zodra we een thread hebben gemaakt, moeten we de uitvoering starten door de methode start() aan te roepen.

runnable.start();

I have written a lot of posts explaining the concepts of multithreading in Java. You can go through these in sequence to learn everything about multithreading, its real-life usage, thread lifecycle, thread pool, etc.

1. Java Thread en Runnable

Dit is de eerste post over de Thread-klasse en de Runnable-interface. Je zult ook leren over Process en Thread. Wat is het verschil tussen Thread en Process? Voordelen van het gebruik van Threads en hoe we Threads kunnen maken met behulp van de Runnable-interface en Thread-klasse. Deze post vergelijkt ook de Runnable-interface met de Thread-klasse.

2. Java Thread Sleep

Java Thread sleep wordt gebruikt om de uitvoering van de huidige thread te pauzeren. We zullen Thread sleep uitgebreid gebruiken in toekomstige berichten, dus het is goed om te weten hoe het werkt en of het nauwkeurig is of niet.

3. Java Thread Join

Soms moeten we wachten tot andere threads hun uitvoering hebben voltooid voordat we verder kunnen gaan. We kunnen dit bereiken met behulp van de Thread join-methode, leer hoe het werkt en wanneer we het moeten gebruiken.

4. Java Thread States

Het begrijpen van de verschillende staten van threads is belangrijk. Leer hoe een thread van staat verandert en hoe het besturingssysteem de staat van een thread wijzigt met de threadplanner.

5. Java Thread wait, notify en notifyAll

De Java Object-klasse bevat drie methoden om de vergrendelingsstatus van een resource te communiceren. Leer met voorbeeldgebruik van deze methoden in een eenvoudige Wait-Notify-implementatie.

6. Threadveiligheid en Synchronisatie

We weten dat Threads objectresources delen, wat kan leiden tot gegevenscorruptie omdat deze bewerkingen niet atomair zijn. Leer hoe we threadveiligheid kunnen bereiken in Java met behulp van verschillende methoden. Lees deze post om te leren over het juiste gebruik van synchronisatie, gesynchroniseerde methoden en gesynchroniseerde blokken.

7. Java Uitzondering in hoofdthread

De JVM creëert de eerste thread met behulp van de main-methode. Deze post legt enkele veelvoorkomende uitzonderingen uit die we in het dagelijks leven zien en wat de oorzaak ervan is en hoe we ze kunnen oplossen.

8. Threadveiligheid in Singletonklasse

In dit artikel leer je de basisconcepten van het maken van een Singletonklasse. Wat zijn de problemen met threadveiligheid bij verschillende implementaties? Hoe kunnen we threadveiligheid bereiken in een Singletonklasse.

9. Draad in Java

A simple article explaining daemon threads and how we can create daemon threads in java.

10. Java Thread Local

We weten dat threads de variabelen van een object delen, maar wat als we thread-local variabelen op klasseniveau willen hebben? Java biedt de ThreadLocal-hulpprogrammaklasse aan om thread-local variabelen te creëren. Lees verder om te leren hoe we ThreadLocal-variabelen in het Java-programma kunnen maken.

11. Java Thread Dump

Java Thread dump geeft informatie over de huidige thread. Een thread dump is handig om prestatieproblemen in de applicatie te analyseren. Je kunt een thread dump gebruiken om deadlock-situaties te vinden en op te lossen. Deze post legt verschillende methoden uit die kunnen worden gebruikt om thread dumps in Java te genereren.

12. Hoe Deadlocks analyseren in Java

Deadlock is een situatie waarin meerdere threads op elkaar wachten om bronnen vrij te geven, waardoor een cyclische afhankelijkheid ontstaat. Dit artikel bespreekt de situatie waarin we een deadlock kunnen krijgen in een Java-programma. Hoe we een Thread-dump kunnen gebruiken om de deadlock te vinden en de beste praktijken om deadlock in een Java-programma te vermijden.

13. Java Timer Thread

Deze post legt uit hoe we de klassen Java Timer en TimerTask kunnen gebruiken om taken te maken die op geplande intervallen worden uitgevoerd, met een voorbeeldprogramma dat het gebruik ervan toont, en hoe we de timer kunnen annuleren.

14. Java Producer Consumer-probleem

Voor Java 5 kon het producent-consumentprobleem worden opgelost met behulp van de methoden wait() en notify(), maar de introductie van BlockingQueue heeft het heel eenvoudig gemaakt. Leer hoe we BlockingQueue kunnen gebruiken om het producent-consumentprobleem in Java op te lossen.

15. Java Thread Pool

Java Thread Pool is een verzameling van worker threads die wachten om taken te verwerken. De introductie van de Executor-framework in Java 5 heeft het heel eenvoudig gemaakt om een thread pool te creëren in Java. We kunnen Executors en ThreadPoolExecutor-klassen gebruiken om een thread pool te creëren en te beheren.

16. Java Callable Future

Soms willen we dat onze Thread enkele waarden retourneert die we kunnen gebruiken. In dat geval kunnen we Java 5 Callable gebruiken, dat vergelijkbaar is met de Runnable-interface. We kunnen het Executor-framework gebruiken om Callable-taken uit te voeren.

17. Java FutureTask Voorbeeld

FutureTask klasse is de basis concrete klasse die de Future interface implementeert. We gebruiken het met Callable implementatie en Executors voor asynchrone verwerking. De FutureTask klasse biedt implementatiemethoden om de staat van de taak te controleren en de waarde terug te geven aan het roepende programma zodra de verwerking is voltooid. Het komt goed van pas wanneer je sommige van de implementatiemethoden van de Future interface wilt overschrijven.

Conclusie

Multithreading is een zeer breed onderwerp en alles erover schrijven in een enkele post zou niet mogelijk zijn geweest. Als je de bovenstaande posts in volgorde doorgaat, zul je alles leren over multithreading in Java.