Többszálú Java nyelven
A Java virtuális gép támogatja a párhuzamos számítástechnikát . Minden számítás elvégezhető egy vagy több szál kontextusában. Könnyen beállíthatunk hozzáférést ugyanahhoz az erőforráshoz vagy objektumhoz több szál számára, valamint beállíthatunk egy szálat egyetlen kódblokk végrehajtására.
Minden fejlesztőnek szinkronizálnia kell a munkát a szálakkal az olvasási és írási műveletek során azokhoz az erőforrásokhoz, amelyekhez több szál van hozzárendelve.
Fontos, hogy az erőforrás elérésekor naprakész adatokkal rendelkezzen, hogy egy másik szál módosíthassa azokat, és Ön a legfrissebb információkat kapja. Még ha egy bankszámlát vesszük is példának, addig amíg meg nem érkezett rá a pénz, addig nem tudod használni, ezért fontos, hogy mindig naprakész adatokkal rendelkezz. A Java speciális osztályokkal rendelkezik a szálak szinkronizálására és kezelésére.
Szálobjektumok
Minden a fő (fő) szállal kezdődik, vagyis legalább a programodban már van egy futó szál. A fő szál további szálakat hozhat létre a Callable vagy Runnable használatával . A létrehozás csak a visszatérési eredményben tér el, a Runnable nem ad vissza eredményt, és nem dobhat ellenőrzött kivételt. Ezért jó lehetőséget kap a hatékony munkavégzésre a fájlokkal, de ez nagyon veszélyes, és óvatosnak kell lennie.
A szál végrehajtását külön CPU magon is ütemezheti. A rendszer könnyedén mozoghat a szálak között, és a megfelelő beállításokkal végrehajthat egy adott szálat: vagyis az adatot kiolvasó szál fut először, amint van adatunk, majd átadjuk az érvényesítésért felelős szálnak, ezt követően átadjuk a szálnak, hogy végre hajtson néhány üzleti logikát, és egy új szál írja vissza őket. Ilyen helyzetben 4 szál felváltva dolgoz fel adatokat, és minden gyorsabban fog működni, mint egy szál. Minden ilyen adatfolyamot natív operációs rendszer adatfolyammá alakítanak át, de az átalakítás módja a JVM megvalósításától függ.
A Thread osztály szálak létrehozására és kezelésére szolgál. Rendelkezik szabványos vezérlőmechanizmusokkal, valamint absztraktokkal, például osztályokkal és gyűjteményekkel a java.util.concurrent webhelyről .
Szálszinkronizálás Java nyelven
A kommunikációt az objektumokhoz való hozzáférés megosztása biztosítja. Ez nagyon hatékony, ugyanakkor nagyon könnyű hibázni a munka során. A hibák két esetben fordulnak elő: szál interferencia - ha egy másik szál zavarja a szálat, és memória konzisztencia - memória konzisztencia. Ezeknek a hibáknak a megoldására és megelőzésére különböző szinkronizálási módszereket alkalmazunk.
A Java-ban a szálszinkronizálást monitorok kezelik, ez egy magas szintű mechanizmus, amely egyszerre csak egy szálnak teszi lehetővé ugyanazon monitor által védett kódblokk végrehajtását. A monitorok viselkedését a zárak szempontjából veszik figyelembe; egy monitor - egy zár.
A szinkronizálásnak számos fontos pontja van, amelyekre figyelni kell. Az első pont a kölcsönös kizárás – csak egy szál birtokolhatja a monitort, így a monitoron történő szinkronizálás azt jelenti, hogy amint egy szál belép a monitor által védett szinkronizált blokkba, egyetlen másik szál sem léphet be a monitor által védett blokkba. az első szál kilép a szinkronizált blokkból. Ez azt jelenti, hogy több szál egyszerre nem férhet hozzá ugyanahhoz a szinkronizált blokkhoz.
De a szinkronizálás nem csak kölcsönös kizárás. A szinkronizálás biztosítja, hogy a szinkronizált blokk előtt vagy azon belül a memóriába írt adatok láthatóak legyenek az ugyanazon a monitoron szinkronizált többi szál számára. A blokkból való kilépés után elengedjük a monitort, és egy másik szál megragadhatja és elkezdheti végrehajtani ezt a kódblokkot.
Amikor egy új szál rögzíti a monitort, hozzáférünk és képesek vagyunk végrehajtani ezt a kódblokkot, és ekkor a változók a fő memóriából töltődnek be. Ekkor láthatjuk a monitor előző kiadása által láthatóvá tett összes bejegyzést.
A mezőn történő olvasás-írás atomi művelet, ha a mezőt illékonynak nyilvánították , vagy egy egyedi zárolás védi, amelyet bármilyen olvasás-írás előtt szereztek be. De ha továbbra is hibát észlel, akkor hibaüzenetet kap az újrarendelésről (rendelés módosítása, újrarendelés). Ez a helytelenül szinkronizált többszálú programokban nyilvánul meg, ahol egy szál megfigyelheti a többi szál által előidézett hatásokat.A szálak kölcsönös kizárásának és szinkronizálásának hatása, vagyis helyes működésük csak egy olyan szinkronizált blokkba vagy metódusba való belépéssel érhető el, amely implicit módon zárolást kap, vagy kifejezetten zárolást szerez. Az alábbiakban erről fogunk beszélni. Mindkét munkamódszer hatással van a memóriájára, és fontos, hogy ne feledkezzünk meg az illékony változókkal való munkavégzésről.
Illékony mezők Java nyelven
Ha egy változó értéke volatile , akkor globálisan elérhető. Ez azt jelenti, hogy ha egy szál hozzáfér egy illékony változóhoz, akkor az értékét a gyorsítótárból való felhasználás előtt kapja meg.
Az írás úgy működik, mint a monitor kiadása, az olvasás pedig a monitor rögzítése. A hozzáférés a „korábban végrehajtott” típusú relációban történik. Ha kitalálja, az A szál csak a B szál változója lesz látható, amikor hozzáfér egy ingadozó változóhoz. Vagyis garantáltan nem veszíti el a többi szál változásait.
Az illékony változók atomiak, vagyis egy ilyen változó olvasásakor ugyanaz a hatás érvényesül, mint a zárolás megszerzésekor - a memóriában lévő adatokat érvénytelennek vagy hibásnak nyilvánítják, és az illékony változó értékét ismét a memóriából olvassa ki . Íráskor a memóriára gyakorolt hatást használják, valamint a zár feloldásakor - egy illékony mező kerül a memóriába.
Java párhuzamos
Ha szuperhatékony és többszálú alkalmazást szeretne készíteni, akkor a JavaConcurrent könyvtár osztályait kell használnia , amelyek a java.util.concurrent csomagban találhatók .
A könyvtár nagyon terjedelmes és különböző funkciókkal rendelkezik, ezért nézzük meg, mi van benne, és osszuk fel néhány modulra:
A Concurrent Collections többszálú környezetben való munkavégzéshez szükséges gyűjtemények halmaza. A teljes gyűjteményhez való hozzáférést blokkoló Collections.synchronizedList alapburkoló helyett az adatszegmenseken zárolásokat vagy várakozásmentes algoritmusokat használnak az adatok párhuzamos olvasására.
Várólisták – nem blokkoló és blokkoló várólisták többszálú környezetben való munkavégzéshez. A nem blokkoló várólisták a sebességre és a működésre összpontosítanak a szálak blokkolása nélkül. A blokkoló sorok alkalmasak arra a munkára, amikor „lassítani” kell a termelői vagy fogyasztói szálakat . Például olyan helyzetben, amikor néhány feltétel nem teljesül, a sor üres vagy megtelt, vagy nincs szabad Fogyasztó „a.
A szinkronizálók a szálak szinkronizálására szolgáló segédprogramok. Erőteljes fegyvert jelentenek a "párhuzamos" számítástechnikában.
Az Executors egy keretrendszer a szálkészletek kényelmesebb és egyszerűbb létrehozásához, könnyen beállítható az aszinkron feladatok ütemezése az eredmények megszerzésével.
Zárak sok rugalmas szál szinkronizálási mechanizmusok képest az alapvető szinkronizált , várjon , értesítsen , notifyAll .
Az atomok olyan osztályok, amelyek támogatják az atomi műveleteket primitíveken és hivatkozásokon.