Wat is concurrency in Java?
In de wereld van vandaag ontwikkelt alles zich snel. Er is altijd een verbetering mogelijk in alles. Zo is het ook met onze programmeertaal. Tegenwoordig verwachten we met onze moderne technologieën dat dingen met gemak en met hoge snelheid worden gedaan. Om meerdere dingen tegelijkertijd te doen of om meerdere dingen tegelijkertijd te doen, ontstond het concept van gelijktijdigheid. Dus wat is eigenlijk gelijktijdigheid, wat is het nut ervan, waarom is dit echt nodig en nog veel meer. We zullen proberen dergelijke vragen aan te raken en ze in dit artikel een voor een te beantwoorden. Laten we onze discussie dus meenemen naar een algemene basissectie die de definitie is van gelijktijdigheid. In dit onderwerp gaan we meer te weten komen over wat Concurrency in Java is.
Definitie van gelijktijdigheid?
Dus wat is gelijktijdigheid eigenlijk? Nou, om dat te beantwoorden, laten we een gemeenschappelijk scenario nemen. Stel dat u tijdens het lezen van dit artikel meerdere dingen tegelijkertijd probeert te doen, misschien probeert u ook een notitie te maken, misschien probeert u het te begrijpen of denkt u aan iets. Dus in eenvoudige woorden, je probeert meerdere dingen parallel te doen. Dit is wat een gelijktijdigheid betekent. Concurrency voert eenvoudig meerdere taken parallel aan elkaar uit. We zullen in dit artikel concurrency bespreken in het kader van Java als programmeertaal.
In feite, in Java of in het algemeen in elke programmeertaal, is het de draad die verantwoordelijk is voor het dragen van concurrency. De basisrol van deze threads is om de parallelle uitvoering van taken te vergemakkelijken. Laten we ondertussen een basisdefinitie van thread hebben.
Dus wat is een draad?
Een thread is een lichtgewicht proces met een eigen call-stack. Een thread heeft echter het recht om toegang te krijgen tot gedeelde gegevens van andere threads die volgens hetzelfde proces worden uitgevoerd. Binnen een Java-toepassing kunnen we veel threads gebruiken om parallelle verwerking of gelijktijdigheid te bereiken.
Laten we nu naar ons volgende onderwerp gaan, namelijk:
Gelijktijdigheid in Java-definitie?
Dus in Java of een andere programmeertaal zoals C #, enz., Heeft alle taal van OOP een concept van threading. In Java hebben we verschillende processen die worden uitgevoerd door verschillende threads te maken om concurrency te bereiken
Laten we na deze eenvoudige definitie ons nieuwe onderwerp bespreken, namelijk:
Wat maakt Java-applicaties gelijktijdig?
De eerste klasse, die men nodig heeft om een Java-toepassing gelijktijdig te maken, is de klasse java.lang.Thread. java.lang.Thread-klasse is verantwoordelijk voor alle concurrency-concepten in de programmeertaal Java. Hierna hebben we java.lang.Runnable interface om het threadgedrag uit de threadklasse te abstraheren.
Andere klassen die we nodig hebben om een geavanceerde toepassing te bouwen, worden gebruikt uit het java.util.concurrent-pakket dat is toegevoegd in Java 1.5.
Daarmee hebben we een nieuwe vraag bereikt die is:
Is Java Concurrency echt zo eenvoudig?
Het lijkt erop dat het implementeren van concurrency in Java vrij eenvoudig is. Het is echter echt niet zo. Laten we ervoor zorgen.
Onze bovenstaande discussie geeft in het algemeen de indruk dat gelijktijdigheid inderdaad een eenvoudig, goed concept is en vrij eenvoudig te implementeren. Welnu, als we op een betere manier controleren en proberen het te begrijpen, vinden we dat het een goed begrip van basisconcepten vereist, evenals een grondig begrip van wat we moeten bereiken.
Als we gelijktijdige toepassingen vergelijken met een toepassing met één thread, vinden we over het algemeen dat een gelijktijdige toepassing complex is in termen van ontwerp en begrip. Code die door meerdere threads wordt uitgevoerd, vereist speciale aandacht en middelen voor toegang tot gedeelde gegevens. Fouten die verschijnen als gevolg van onjuiste thread-synchronisatie zijn moeilijk te debuggen en op te lossen. In de meeste scenario's worden deze bugs ook niet geïdentificeerd in de beginfase, in feite worden ze gedetecteerd in de prod-modus, die nog moeilijker te reproduceren is.
Afgezien van bugs en veelvoorkomende defecten, vereisen gelijktijdige threads meer middelen om de toepassing uit te voeren
Problemen en verbetering van concurrency - Uitleg met voorbeeld
Dus eigenlijk zijn er twee soorten problemen die toewijzen vanwege concurrency. Deze problemen kunnen grofweg in twee categorieën worden ingedeeld
- Draad interferentiefouten
- Geheugenconsistentie fouten
Laten we elk een voor een begrijpen
Draadinterferentiefouten - Laten we het begrijpen met een eenvoudig voorbeeld.
Stel dat we een tellerfunctie hebben, wiens basisrol is om de teller of het aantal van een getal te verhogen. Stel nu dat we twee threads hebben, thread A en thread B. Stel dat thread A de beginwaarde als 0 leest. De volgende stappen worden nu sequentieel uitgevoerd.
- Thread A leest de beginwaarde als 0
- Thread B leest de beginwaarde als 0
- Thread A verhoogt waarde met 1. De nieuwe waarde is nu 1
- Draad B verhoogt ook parallel de waarde tot 1.
- Thread A schrijft bijgewerkte waarde die 1 is in de geheugencel
- Thread B herhaalt ook dezelfde stap, die wordt geschreven in de bijgewerkte waarde van geheugencel 1
Dus hier ontstaat het probleem. Twee threads A & B, voer de code twee keer uit en de verwachte waarde is 2, maar wat wordt weerspiegeld is 1. Dit is het grootste probleem wat meerdere threads kunnen veroorzaken
Hoe dit kan worden opgelost?
Thread-interferentiefouten kunnen worden opgelost door de toegang tot gedeelde variabelen te synchroniseren. We moeten gesynchroniseerd blijven voor de bijgewerkte waarden tussen de gedeelde gegevens
Laten we hiermee het tweede type fout bekijken
Geheugenconsistentie Fouten
Geheugeninconsistentiefouten treden meestal op wanneer verschillende threads proberen hetzelfde te lezen of inconsistente weergaven hebben over hetzelfde gegeven. Dit gebeurt meestal wanneer de eerste thread sommige gedeelde gegevens bijwerkt en deze bijgewerkte waarde niet wordt doorgegeven aan de tweede of andere threads en zij oude gegevens lezen.
Laten we eens kijken waarom dit gebeurt?
Welnu, hier kunnen veel oorzaken voor zijn. Gewoonlijk voert de compiler over het algemeen veel verschillende optimalisaties uit om de applicatie te verbeteren. Het kan ook instructiesequenties bijwerken om de prestaties te optimaliseren. Zelfs in het algemeen proberen processors ook codes te optimaliseren, een CPU kan bijvoorbeeld de huidige waarde van een variabele uit een cachegeheugen of tijdelijk register lezen in plaats van het hoofdgeheugen
Conclusie - Wat is concurrency in Java?
Gelijktijdigheid is een zeer belangrijk kenmerk van de taal van elke OOP. Threading geeft ons de mogelijkheid om meerdere processen parallel aan elkaar uit te voeren. Het helpt ons onze complexe taak sneller uit te voeren. Bij professionals heeft concurrency echter ook weinig nadelen. Het gebruik van threading veroorzaakt zwaar gebruik van middelen
Aanbevolen artikelen
Dit is een gids geweest voor wat concurrency in Java is. Hier hebben we de problemen en verbeteringen in concurrency met voorbeeld besproken. U kunt ook onze andere voorgestelde artikelen doornemen voor meer informatie -
- Wat is multithreading in Java?
- Hoe database te verbinden in Java?
- Wat is multithreading in Java?
- Wat is J2EE?