Használata mutexek és szemafor
A könyv célja, hogy egy széles körű iránt érdeklődő olvasók programozás C # .Vvedite rövid összefoglalót itt
Könyv: C # 4.0: Átfogó útmutató
Használata mutexek és szemafor
Szakaszok ezen az oldalon:
Használata mutexek és szemafor
A legtöbb esetben, ha szeretne szinkronizálni, és elég üzemeltető zár. Mindazonáltal bizonyos esetekben, mint például a hozzáférés korlátozása a megosztott erőforrások, sokkal kényelmesebb szinkronizációs mechanizmusokra építve a .NET-keretrendszer. Mi az alábbiakban tárgyaljuk érdekében két ilyen mechanizmusok: mutexek és a szemafor.
Mutex egy kölcsönösen kizáró óra objektumot. Ez azt jelenti, hogy lehet beszerezni csak az áramlás sorban. Mutex célja olyan esetekben, amikor a megosztott erőforrás lehet használni egyszerre egy patak. Tegyük fel, hogy a naplófájl osztozik számos folyamat, de ezek közül csak egy adatot lehet rögzíteni naplófájl bármikor. Szinkronizálja az eljárások ebben a helyzetben ideális mutexek.
Mutex tartjuk System.Threading.Mutex osztályban. Ő több konstruktőrök. Az alábbiakban a két leggyakoribb tervezők.
nyilvános Mutex ()
nyilvános Mutex (bool initiallyOwned)
Az első forma a szerkesztő létrehozza mutexek, amely kezdetben senki sem birtokolja. A második forma kezdeti állapotban mutex hívó szál megragadja amikor ini tiallyOwned paraméter egy logikai érték igaz. Egyébként senki sem birtokolja a mutex.
Annak érdekében, hogy a mutexet, a programkód hívjanak WaitOne () metódus erre mutexek. WaitOne () módszer osztálytól örökölt Mutex Thread.WaitHandle osztály. Az alábbiakban a legegyszerűbb formában.
WaitOne () módszer vár addig, amíg egy mutex amelyre hívták. Következésképpen ez a módszer letiltja végrehajtását hívó szálat, amíg, amíg nem válik hozzáférhetővé az említett mutexek. Ő mindig visszatér egy logikai érték igaz.
A kód már nem kell tartani a mutex, a kibocsátás meghívásával ReleaseMutex (). amely alább látható formában.
public void ReleaseMutex ()
Ebben a formában ReleaseMutex () metódus felszabadítja a mutex, amelyre hívták, amely lehetővé teszi egy másik szál, hogy a mutexet.
Használható a célja a mutex szinkronizálni a hozzáférés egy megosztott erőforrás fent említett WaitOne () és ReleaseMutex () használnak, amint az a következő kódrészletet.
Mutex myMtx = új Mutex ();
//.
myMtx.WaitOne (); // várni mutexek
// Jut a részvény.
myMtx.ReleaseMutex (); // kiadja a mutex
Amikor hívja WaitOne () végrehajtása megfelelő adatfolyam függeszteni addig az időpontig, amíg a mutexet. Eljárás hívás ReleaseMutex () mutexeket felszabadul, és azután kapott egy másik téma. Ezzel a megközelítéssel, hogy a szinkronizálási egyidejű hozzáférést a megosztott erőforrás korlátozódik csak egy szál.
A következő példa a program szinkronizációs mechanizmus fent leírt bizonyított a gyakorlatban. Ebben a programban két stream formájában osztályok és IncThread DecThread. hogy előírja a hozzáférést egy közös forrása: változó SharedRes.Count. Az áramlási IncThread SharedRes.Count változó növeljük, és az áramlás DecThread - csökkentjük. Annak érdekében, hogy az egyidejű hozzáférést mindkét áram a megosztott erőforrás SharedRes.Count ez a hozzáférés szinkronizálva mutexek Mtx. Ugyancsak tagja SharedRes osztályban.
Ez a program a következő eredményt adja.
Növeli a menet vár a mutex.
Növeli a szál kapja a mutex.
Csökkentést a menet vár a mutex.
Az áramlási áram növekszik, SharedRes.Count = 1
Az áramlási áram növekszik, SharedRes.Count = 2
Az áramlási áram növekszik, SharedRes.Count = 3
Az áramlási áram növekszik, SharedRes.Count = 4
Az áramlási áram növekszik, SharedRes.Count = 5
Takarmány növekszik elengedi a mutex.
Csökkentést a szál kapja a mutex.
Az áramlás irányát, csökkentjük, SharedRes.Count = 4
Az áramlás irányát, csökkentjük, SharedRes.Count = 3
Az áramlás irányát, csökkentjük, SharedRes.Count = 2
Az áramlás irányát, csökkentjük, SharedRes.Count = 1
Az áramlás irányát, csökkentjük, SharedRes.Count = 0
Csökkentjük flow elengedi a mutex.
Mint az a fenti eredmény, a hozzáférés egy megosztott erőforrás (változó SharedRes.Count) szinkronizált, ezért a változó értékeit lehet egyszerre megváltoztatni csak egy patak.
Növeli a menet vár a mutex.
Növeli a szál kapja a mutex.
Csökkentést a menet vár a mutex.
Csökkentést a szál kapja a mutex.
Az áramlási áram növekszik, SharedRes.Count = 1
Az áramlás irányát, csökkentjük, SharedRes.Count = 0
Az áramlási áram növekszik, SharedRes.Count = 1
Az áramlás irányát, csökkentjük, SharedRes.Count = 0
Az áramlási áram növekszik, SharedRes.Count = 1
Az áramlás irányát, csökkentjük, SharedRes.Count = 0
Az áramlási áram növekszik, SharedRes.Count = 1
Az áramlás irányát, csökkentjük, SharedRes.Count = 0
Az áramlási áram növekszik, SharedRes.Count = 1
Takarmány növekszik elengedi a mutex.
Az áramlás irányát, csökkentjük, SharedRes.Count = 0
Csökkentjük flow elengedi a mutex.
Amint az a fenti eredményt, anélkül, mutex növelésével és csökkentésével SharedRes.Count változó többször előfordul, véletlenszerűen, mint a sorozatban.
Mutex létre az előző példában, amelyről csak a folyamat, amelyben létrejöttek. De akkor létrehozhat egy mutexek, és hogy ő volt ismert máshol. Ehhez meg kell nevezni. Az alábbiakban formatervezés létrehozásáshoz mutexek.
nyilvános Mutex (bool initiallyOwned, string name)
nyilvános Mutex (bool initiallyOwned, string neve, ki bool createdNew)
Mindkét formában, a tervező neve jelöli a pontos nevét a mutex. Míg az első formája a kivitelező paraméter ini tiallyOwned egy logikai értéke igaz. tulajdonjoga a mutexeket kért. De mivel a mutexeket tulajdonosa egy másik folyamat a rendszer szinten, ez a lehetőség jobban meghatározza a logikai érték hamis. Visszatérése után a második formája a kivitelező createdNew paraméter lesz logikai értéke igaz. ha birtokában a mutex igényelt és kapott, és egy logikai érték hamis. ha a tulajdonosi kérés teljesítését megtagadta. Van egy harmadik formája Mutex típusú kivitelező. ahol megadhatja, hogy milyen típusú objektum ellenőrzések hozzáférést MutexSecurity. Named mutexes szinkronizálható interakciós folyamatokat.
Még egy utolsó pont: a falon, megszerezzék a mutexeket szabad csinálni egy vagy több további hívások WaitOne () metódus hívása előtt ReleaseMutex (). mindezen további hívások lesz sikeres. Ez azt jelenti, hogy a további metódushívások WaitOne () nem akadályozzák az áramlást, amely már rendelkezik a mutex. De ez a szám WaitOne eljárás hívás () meg kell egyeznie a hívások száma ReleaseMutex () metódus, hogy kiadja a mutex.
Szemafor mutex hasonló, kivéve, hogy egyidejű hozzáférést biztosít a megosztott erőforrás nem egy, hanem több szálat. Ezért a szemafor alkalmas szinkronizálására számos erőforrást. Szemafor szabályozza a hozzáférést a megosztott erőforrás felhasználásával a számláló erre a célra. Ha a számláló értéke nagyobb, mint nulla, akkor a hozzáférést a forrás megengedett. Ha ez az érték nulla, akkor a hozzáférést a forrás tilos. A számláló megszámláljuk engedélyek számát. Ezért az erőforrás elérését áramlás, engedélyt kell beszereznie a szemafor.
Jellemzően egy patak, amely előírja a hozzáférés egy megosztott erőforrás, megpróbál engedélyt a szemafor. Ha az érték a szemafor számláló értéke nagyobb, mint nulla, akkor az áramlás engedélyezték, és a szemafor számláló értéke. Ellenkező esetben a szál blokkolva addig, amíg megkapja az engedélyt. Amikor az áramlás már nem kell hozzáférni a megosztott erőforrás, akkor szabaddá teszi a felbontás, és a szemafor számláló növekszik. Ha egy másik szál vár engedélyt, meg is kapja ezen a ponton. Az egyidejűleg számos érhetik létrehozásakor megadott szemafor. Például, ha létrehoz egy szemafor egyidejűleg, amely csak egyetlen kapcsolat, akkor ez fog működni, mint egy szemafor mutexek.
Szemaforokat különösen hasznosak olyan esetekben, amikor a részvény áll egy csoport vagy erőforrás pool. Például az erőforrás pool állhat számos hálózati kapcsolatok, amelyek mindegyike az adatátvitelre használt. Ezért a folyamat, hálózati kapcsolat szükséges, egyébként, hogy milyen kapcsolat kap. Ebben az esetben a szemafor egy kényelmes mechanizmust kezelését teszi a hálózati kapcsolatokat.
Szemafor végre System.Threading.Semaphore osztályban. amely számos konstruktőrök. Az alábbiakban a legegyszerűbb formája a kivitelező az osztály:
nyilvános Szemafor (int initialCount, int maximumCount)
ahol initialCount - a kezdeti értéke a szemafor számláló engedélyeket, azaz összeget, amelyet eredetileg rendelkezésre álló felbontást; maximumCount - a maximális értékét a számláló, azaz A maximális engedélyek számát, hogy tud adni a szemafor.
Szemaforhoz használunk ugyanolyan módon, mint a korábban ismertetett mutexet. Annak érdekében, hogy hozzáférjen az erőforrás a programkód nevezik WaitOne () metódus a szemafor. Ez a módszer örökölt az WaitHandle osztály Szemafor osztályban. WaitOne () módszer megvárja, amíg, amíg a szemafor, amelyre ez az úgynevezett. Így gátolja végrehajtását a hívó szálat, amíg a szemafor nem adott engedélyt a hozzáférést az erőforráshoz.