Hoi! Allereerst gefeliciteerd: je hebt het onderwerp Multithreading in Java bereikt! Dit is een serieuze prestatie - je hebt een lange weg afgelegd. Maar bereid je voor: dit is een van de moeilijkste onderwerpen in de cursus. En het is niet zo dat we hier complexe klassen of veel methoden gebruiken: in feite gebruiken we er minder dan twintig. Het is meer dat je je manier van denken een beetje moet veranderen. Voorheen werden uw programma's opeenvolgend uitgevoerd. Sommige regels code kwamen na andere, sommige methoden kwamen na andere, en alles was in wezen duidelijk. Eerst hebben we iets berekend, vervolgens het resultaat op de console weergegeven en toen eindigde het programma. Om multithreading te begrijpen, is het beter om in termen van parallellisme te denken. Laten we beginnen met iets heel eenvoudigs: ) Stel je voor dat je gezin van het ene huis naar het andere verhuist. Het verzamelen van al uw boeken zal een belangrijk onderdeel van de verhuizing zijn. Je hebt veel boeken verzameld en je moet ze in dozen stoppen. Momenteel ben jij de enige die beschikbaar is. Mam maakt eten klaar, broer pakt kleren in en zus ging naar de winkel. Alleen kun je het op de een of andere manier redden. Vroeg of laat voltooi je de taak zelf, maar het kost veel tijd. Je zus komt echter over 20 minuten terug van de winkel en ze heeft niets anders te doen. Zodat ze mee kan doen. De taak is niet veranderd: boeken in dozen stoppen. Maar het wordt twee keer zo snel uitgevoerd. Waarom? Omdat het werk parallel gebeurt. Twee verschillende 'threads' (jij en je zus) voeren tegelijkertijd dezelfde taak uit. En als er niets verandert, dan ontstaat er een enorm tijdsverschil met de situatie waarin je alles alleen doet. Als broer binnenkort klaar is met zijn werk, kan hij je helpen en gaat het nog sneller.
![Multithreading in Java: wat het is, de voordelen en veelvoorkomende valkuilen - 4]()
Stel je voor dat Thread-1 interageert met een Object-1, en dat Thread-2 interageert met Object-2. Verder is het programma zo geschreven dat:
![Multithreading in Java: wat het is, de voordelen en veelvoorkomende valkuilen - 6]()
'Java Concurrency in Practice' is geschreven in 2006, maar heeft zijn relevantie niet verloren. Het is gewijd aan multithreaded Java-programmering - van de basis tot de meest voorkomende fouten en antipatronen. Als je op een dag besluit een multithreading-goeroe te worden, is dit boek een must-read. Tot ziens in de volgende lessen! :)
Problemen opgelost door multithreading
Multithreading is eigenlijk uitgevonden om twee belangrijke doelen te bereiken:-
Doe meerdere dingen tegelijk.
In het bovenstaande voorbeeld voerden verschillende threads (gezinsleden) verschillende acties parallel uit: ze deden de afwas, gingen naar de winkel en pakten dingen in.
We kunnen een voorbeeld geven dat nauwer verband houdt met programmeren. Stel je hebt een programma met een gebruikersinterface. Wanneer u in het programma op 'Doorgaan' klikt, moeten er enkele berekeningen worden uitgevoerd en zou de gebruiker het volgende scherm moeten zien. Als deze acties opeenvolgend zouden worden uitgevoerd, zou het programma gewoon blijven hangen nadat de gebruiker op de knop 'Doorgaan' klikt. De gebruiker krijgt het scherm met de knop 'Doorgaan' te zien totdat het programma alle interne berekeningen heeft uitgevoerd en het gedeelte bereikt waar de gebruikersinterface wordt vernieuwd.
Nou, ik denk dat we een paar minuten wachten!
![Multithreading in Java: wat het is, de voordelen en veelvoorkomende valkuilen - 3]()
Of we kunnen ons programma herwerken, of, zoals programmeurs zeggen, 'paralleliseren'. Laten we onze berekeningen op één thread uitvoeren en de gebruikersinterface op een andere tekenen. De meeste computers hebben genoeg middelen om dit te doen. Als we deze route volgen, zal het programma niet vastlopen en zal de gebruiker soepel tussen schermen bewegen zonder zich zorgen te maken over wat er binnen gebeurt. Het een staat het ander niet in de weg :)
-
Berekeningen sneller uitvoeren.
Alles is hier veel eenvoudiger. Als onze processor meerdere cores heeft, en de meeste processors hebben dat tegenwoordig, dan kunnen meerdere cores onze takenlijst parallel aan. Het is duidelijk dat als we 1000 taken moeten uitvoeren en elk een seconde duurt, één kern de lijst in 1000 seconden kan voltooien, twee kernen in 500 seconden, drie in iets meer dan 333 seconden, enz.
public class MyFirstThread extends Thread {
@Override
public void run() {
System.out.println("I'm Thread! My name is " + getName());
}
}
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
MyFirstThread thread = new MyFirstThread();
thread.start();
}
}
}
Problemen veroorzaakt door multithreading
In ons voorbeeld met boeken zag je dat multithreading zeer belangrijke taken oplost en onze programma's sneller kan maken. Vaak vele malen sneller. Maar multithreading wordt als een moeilijk onderwerp beschouwd. Als het verkeerd wordt gebruikt, creëert het inderdaad problemen in plaats van ze op te lossen. Als ik zeg 'creëert problemen', bedoel ik niet in een of andere abstracte zin. Er zijn twee specifieke problemen die multithreading kan veroorzaken: impasse en race-omstandigheden. Deadlock is een situatie waarin meerdere threads wachten op bronnen die door elkaar worden vastgehouden en geen van hen kan blijven draaien. We zullen er in de volgende lessen meer over vertellen. Het volgende voorbeeld is voor nu voldoende:
Stel je voor dat Thread-1 interageert met een Object-1, en dat Thread-2 interageert met Object-2. Verder is het programma zo geschreven dat:
- Thread-1 stopt met communiceren met Object-1 en schakelt over naar Object-2 zodra Thread-2 stopt met communiceren met Object-2 en overschakelt naar Object-1.
- Thread-2 stopt met communiceren met Object-2 en schakelt over naar Object-1 zodra Thread-1 stopt met communiceren met Object-1 en overschakelt naar Object-2.
public class MyFirstThread extends Thread {
@Override
public void run() {
System.out.println("Thread executed: " + getName());
}
}
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
MyFirstThread thread = new MyFirstThread();
thread.start();
}
}
}
'Java Concurrency in Practice' is geschreven in 2006, maar heeft zijn relevantie niet verloren. Het is gewijd aan multithreaded Java-programmering - van de basis tot de meest voorkomende fouten en antipatronen. Als je op een dag besluit een multithreading-goeroe te worden, is dit boek een must-read. Tot ziens in de volgende lessen! :)
GO TO FULL VERSION