C# - Mutex osztály használata

forráskód letöltése
Amennyiben többszálú alkalmazásainkban a szálak menedzselését valamilyen okból nem kívánjuk a beépített pooling-ra bízni, hanem inkább magunk szeretnénk azok működését kézben tartani, akkor meg kell találnunk a .NET szinkronizációs osztályait. Egyik ilyen osztály a Mutex, mellyel a különböző erőforrások megoszthatók az egyes szálak között. Cikkünkben bemutatjuk egy példán keresztül, hogy a szálak viselkedése és futása hogyan befolyásolható az osztály segítségével.
Mutex objektumok szerepe
A Mutex osztály példányai olyan szinkronizációs primitívek, melyek segítségével az alkalmazás szálai vagy a számítógép process-ei egymás futásának akadályozása nélkül képesek osztozni a rendszer erőforrásain. Így biztosítható, hogy az adott erőforrást egy időben csak egy szál, illetve process használja.
A Mutex objektum úgy működik, hogy egy szál lefoglal egy Mutex objektumot az adott erőforrás használatának idejére, majd a használat befejezésekor felszabadítja a Mutex objektumot. Ha az adott Mutex-et egy másik szál is lefoglalta (birtokolja), akkor a szál működése addig marad felfüggesztve, amíg a korábban lefoglaló szál el nem végzi a felszabadítást, jelezve, hogy már nem használja az erőforrást.
Több változata lehetséges a Mutex objektum(ok) használatának, melyek közül a Mutex osztály metódusainak meghívásával lehet választani.
Amennyiben az adott szálművelet elvégzésekor a birtokolt Mutex objektum WaitOne metódusát hívjuk meg, akkor jelezzük a szálobjektum számára, hogy a futásának feltétele, hogy az adott Mutex objektum a ReleaseMutex metódus meghívásával felszabadításra kerüljön.
Ugyanakkor arra is van lehetőségünk, hogy egy adott Mutex csoportot vegyen birtokba egy adott szál, melyeket egy tömbben tárolhatunk. Ekkor előírhatjuk, hogy az adott szál futásának feltétele a Mutex-ek egyikének, vagy mindegyikének felszabadítása. Amennyiben egy Mutex felszabadítása is elegendő a szál futásának folytatásához, akkor a Mutex.WaitAny statikus metódus meghívására van szükség, ha pedig minden Mutex-et fel kell szabadítani futás előtt, akkor a Mutex.WaitAll metódus meghívására.
Abban az esetben, ha egy szál normális körülmények között terminál, az általa birtokolt Mutex jelző (signaled) állapotban marad, és a következő várakozó szál birtokába kerül. Ha éppen nincs várakozó szál, akkor a Mutex szintén ebben az állapotban marad.
Gyakorlati felhasználás
A Mutex objektumokat leggyakrabban név nélkül hozzuk létre, a konstruktor azon változatát felhasználva, melyben egy logikai érték beállításával jelezzük a szál tulajdonlási igényét. Példánkban ez az érték TRUE, vagyis a hívó szál tulajdonosa is a Mutex-nek.
private Mutex mutex1 = new Mutex(true);
private Mutex mutex2 = new Mutex(true);
private Mutex mutex3 = new Mutex(true);
Példánkban három szállal dolgozunk, melyek mindegyike ugyanazt a feladatot kapja, nevezetesen azt, hogy a ProgressBar kontrol indikátorát mozgassa a megfelelő értékre egy kis késleltetéssel. Így imitálva egy időigényes műveletet.
Az első szál a mutex1 és a mutex2 objektumokat egy tömbbe gyűjti, és a futást csak akkor folytatja a létrehozás után, ha a Mutex-ek mindegyike felszabadul. A második szál ezek közül csak az egyik felszabadulására vár, míg a harmadik szál a harmadik felszabadulása után futhat. A felszabadításokat a Form három nyomógombjával tehetjük meg, közben megfigyelhetjük, hogy éppen melyik szál kezdi meg a futást.
A szálak inicializálása a hagyományos módszerrel történik. A Start gombra kattintva létrehozzuk a három Thread objektumot.
Thread th1 = new Thread(new ThreadStart(DoStart1));
Thread th2 = new Thread(new ThreadStart(DoStart2));
Thread th3  = new Thread(new ThreadStart(DoStart3));
Meghívjuk Start metódusaikat.
th1.Start();
th2.Start();
th3.Start();
A szálak indulásakor végrehajtjuk a megfelelő metódusokat (DoStart1, ...). Az első szál esetében elvégezzük a tömbbe sorolást, majd meghívjuk a WaitAll metódust, jelezve, hogy a Mutex-ek mindegyikének fel kell szabadulnia ahhoz, hogy a szál futhasson.
Mutex[] mutexList1 = new Mutex[2];
mutexList1[0] = mutex1;
mutexList1[1] = mutex2;
Mutex.WaitAll(mutexList1);
A második esetben már elegendő egy Mutex-et felszabadítanunk.
...
Mutex.WaitAny(mutexList2);
A harmadik szál pedig csak a mutex1 objektumtól függ.
mutex3.WaitOne();
A gombok valamelyikének lenyomásával felszabadíthatjuk a megfelelő Mutex-et, elérve, hogy valamely szál folytassa működését.
mutex1.ReleaseMutex();
...