Javában a szálszinkronizációban használjuk a szemaforokat. Egy számlálóváltozót használó megosztott erőforráshoz való hozzáférés szabályozására szolgál. A Java egy Semaphore osztályt is biztosít, amely konstruktorokat és különböző metódusokat tartalmaz a megosztott erőforrás feletti hozzáférés szabályozására. Ezt később tárgyaljuk ebben a szakaszban.

Mielőtt ebben a szakaszban továbblépnénk, először is meg kell értenünk, mi az a szemafor, a szemafor típusai, hogyan működik, és hogyan kell a szemafort implementálni. Miután mindent tudunk róla, áttérünk a Java szemafor programokra.

Mi az a szemafor?

A szemafor a megosztott erőforráshoz hozzáférni kívánó szálak számának korlátozására szolgál. Más szóval, ez egy nemnegatív változó, amely megosztott a szálak között, amit számlálónak nevezünk. Ez állítja be a szálak határértékét. Egy olyan mechanizmust, amelyben egy szál egy szemaforra várakozik, más szálak jelezhetnek.

• Ha a számláló > 0, a megosztott erőforrásokhoz való hozzáférés biztosított.
• Ha a számláló = 0, a megosztott erőforrásokhoz való hozzáférés megtagadva.

Röviden, a számláló nyomon követi a megosztott erőforrásokhoz adott jogosultságok számát. Ezért a szemafor engedélyt ad a szálaknak egy erőforrás megosztására.

A szemafor jellemzői

A szemafornak a következő jellemzői vannak:

• A szálak közötti szinkronizációt biztosítja.
• A szinkronizáció szintjét csökkenti. Ezért alacsony szintű szinkronizációs mechanizmust biztosít.
• A szemafor nem tartalmaz negatív értéket. Olyan értéket tart, amely vagy nagyobb lehet nullánál, vagy egyenlő nullával.
• A szemafor a tesztművelet és a megszakítások segítségével valósítható meg, a végrehajtáshoz pedig a fájlleírókat használjuk.

A szemafor működése

A szemafor egy számlálóváltozón keresztül ellenőrzi a megosztott erőforrást. A számláló egy nem negatív érték. Vagy 0-nál nagyobb, vagy 0-val egyenlő értéket tartalmaz.

• Ha a számláló > 0, akkor a szál engedélyt kap a megosztott erőforrás elérésére, és a számláló értéke 1-gyel csökken.
• Emás esetben a szál blokkolva lesz, amíg engedélyt nem kap.
• Amikor a szál végrehajtása befejeződik, akkor már nincs szükség az erőforrásra, és a szál felszabadítja azt. Az erőforrás felszabadítása után a számláló értéke 1-gyel növekszik.
• Ha egy másik szál vár az erőforrás megszerzésére, akkor a szál ekkor szerez engedélyt.
• Ha a számláló = 0, akkor a szál nem kap engedélyt a megosztott erőforrás elérésére.

Magyarázzuk el a szemafor működését egy folyamatábra segítségével.

A szemaforok típusai

A szemaforoknak négy típusa van, amelyek a következők:

• Counting Semaphores
• Bounded Semaphores
• Timed Semaphores
• Binary Semaphores

Egyenként részletesen tárgyaljuk.

Számláló szemaforok

A számláló szemaforok arra szolgálnak, hogy megoldják azt a helyzetet, amikor egynél több folyamat akar egyszerre futni a kritikus szakaszban. Ezért ennek a problémának a leküzdésére használjuk a számláló szemaforokat. Vegyük például a következő kódrészletet.

Lássuk a számláló szemaforok megvalósítását.

CountingSemaphoresExample.java

Bounded Semaphores

A felső korlátot a bounded semaphores segítségével állíthatjuk be. Ezt a számoló szemaforok helyett használjuk, mert a számoló szemaforok nem tartalmaznak felső határértéket. A felső határérték azt jelöli, hogy hány jelet tud tárolni. Vegyük például a következő kódrészletet.

Lássuk a korlátos szemaforok megvalósítását.

BoundedSemaphoresExample.java

Timed Semaphores

Az időzített szemaforok lehetővé teszik, hogy egy szál egy meghatározott ideig fusson. Egy adott idő elteltével az időzítő lenullázza és felszabadítja az összes többi engedélyt.

Lássuk az időzített szemaforok megvalósítását.

TimedSemaphoresExample.java

Bináris szemaforok

A bináris szemaforok ugyanazok, mint a számoló szemaforok. De ne feledjük, hogy csak bináris értékeket fogad el, vagy 0-t vagy 1-et. Megvalósítása egyszerű a többi szemaforhoz képest. Ha az érték 1, akkor a jelzőművelet sikeres, ellenkező esetben sikertelen.

Lássuk a bináris szemaforok megvalósítását.

BinarySemaphoresExample.java

Semaphorok Java-ban

Javában ez egy szálszinkronizációs konstrukció. A konstrukció egy számlálónak nevezett változót használ, amely a megosztott erőforrás feletti hozzáférést szabályozza. Ez egy olyan típusú változó, amelyet az egyidejű folyamatok kezelésére és szinkronizálására is használnak. A versenyfeltételek elkerülésére is használják. Korlátozza a szálak számát, amelyek hozzáférhetnek egy megosztott erőforráshoz.

Egy fájlhoz például legfeljebb 10 kapcsolat egyidejű hozzáférését korlátozhatjuk.

Java Semaphore osztály

A Java biztosít egy Semaphore osztályt a szemafor mechanizmus megvalósítására. Ez a java.util.concurrent csomaghoz tartozik. A Serializable interfészt valósítja meg. Ezért kézi implementációra nincs szükség.

A Semaphore osztály a következő két konstruktort biztosítja:

• Semaphore(int permits)
• Semaphore(int permits, boolean fair)

Semaphore(int permits)

Ez létrehoz egy Semaphore-t és argumentumként elemzi az engedélyek számát (a rendelkezésre álló engedélyek kezdeti számát). Megadja, hogy egyszerre hány szál oszthat meg egy erőforrást. A permits értéke negatív is lehet. Ebben az esetben egy release-nek kell bekövetkeznie, mielőtt bármilyen acquires megadásra kerülne.

Szintaktika:

Semaphore(int permits, boolean fair)

Elkészít egy Semaphore-t a megadott számú permits-szal és a megadott fairness beállításokkal.

Szintaktika:

Elkészít két paramétert:

• permits: A permits értéke lehet negatív. Ebben az esetben a felszabadításnak meg kell történnie, mielőtt bármilyen acquires engedélyezésre kerülne.
• fair: Ha az értéket true-ra állítjuk, akkor a szemafor FIFO-t garantál a szálaknak a kérés sorrendjében, false Alapértelmezés szerint az összes szál, amely az erőforrásra vár, meghatározatlan sorrendben engedélyt ad.

A szemafor osztály módszerei

Az osztály a következő módszereket biztosítja:

acquire() módszer: A metódus megszerzi az engedélyeket a szemaforból, blokkolva, amíg nem áll rendelkezésre egy, vagy a szál megszakad. A rendelkezésre álló engedélyek számát 1-gyel csökkenti.

Ha az aktuális szál számára nem áll rendelkezésre engedély, a szál a szálütemezés szempontjából letiltottá válik. Az aktuális szál inaktív állapotba kerül, amíg két dolog közül az egyik meg nem történik:

• Ha a másik szál meghívja a release() metódust az erőforrás felszabadítására, akkor az aktuális szál engedélyeket kap.
• Ha a másik szál megszakítja az aktuális szálat.

Ez InterruptedExceptiont dob, ha az aktuális szál megszakad. A módszer nem ad vissza értéket.

Szintaktika:

release() módszer: Felszabadít egy engedélyt és visszaadja a szemafornak. A rendelkezésre álló engedélyek számát 1-gyel növeli. Ha egy szál megpróbál megszerezni egy engedélyt, a szemafor engedélyt ad a más szálak által éppen felszabadított erőforrás megszerzésére. Továbbá ezt a szálat figyelembe veszi a szálak ütemezésénél.

Szintaktika:

availablePermits() Módszer: A módszer visszaadja az erőforrás megadására rendelkezésre álló engedélyek számát a szemaforban. Általában hibakeresési és tesztelési célokra használják.

Syntax:

Megértjük a fenti módszereket egy egyszerű példán keresztül.

A szemafor zárként való használata

A Java lehetővé teszi számunkra, hogy egy szemafort zárként használjunk. Ez azt jelenti, hogy zárolja az erőforráshoz való hozzáférést. Minden szálnak, amely hozzá akar férni a zárolt erőforráshoz, meg kell hívnia az acquire() metódust, mielőtt hozzáférne az erőforráshoz, hogy megszerezze a zárolást. A szálnak a feladat befejezése után a release() metódus meghívásával kell feloldania a zárat. Ne feledje, hogy a felső korlátot 1-re állítsa be. Vegyük például a következő kódrészletet:

Lássunk egy példát a szemaforra és a szemafor zárként való használatára.

SemaphoreAsLock.java

Kimenet:

Megjegyzés: Amikor a fenti programot végrehajtjuk, minden alkalommal más kimenetet kapunk. Így az Ön kimenete eltérhet a fent látható kimenettől.

Java Semaphore példa

Megértjük a szemafor mechanizmust egy Java programon keresztül. A következő példában létrehoztuk a Semaphore osztály konstruktorát a 3 kezdeti engedélyezési értékkel.

SemaphoreExample.java

Kimenet:

.