Vlákna v C# - 8. díl
 x   TIP: Přetáhni ikonu na hlavní panel pro připnutí webu

Vlákna v C# - 8. dílVlákna v C# - 8. díl

 

Vlákna v C# - 8. díl

Google       Google       1. 11. 2008       30 119×

Obsahem dnešního dílu budou třídy ReaderWriterLockSlim a ReaderWriterLock.

Většinou jsou instance různých tříd, typů, … thread-safe pro čtecí operace, ale ne pro zápis nebo aktualizaci obsahu. To platí třeba i u souborů – klidně dvacet vláken najednou ho může číst, ale jen těžko do něj mohou najednou zapisovat. I když si jednoduchý locking většinou s tímto problémem poradí, může být někdy zbytečně omezující, pokud třeba existuje hodně „čtenářů“ obsahu, ale k nějakému zápisu dojde jen občas. Příkladem může být nějaký server s daty, kde se často používaná data cachují do statických proměnných.

ReaderWriterLockSlim je novinka v .NET frameworku 3.5, kde nahrazuje starší třídu ReaderWriterLock. „Slim“ se podobá svému předku ve funkcionalitě, ale je rychlejší a ve své podstatě jednodušší. Stará verze měla dokonce několik málo známých bugů, které mohly způsobit nepředvídatelné pády aplikace! Proto budu v tomto článku používat novější ReaderWriterLockSlim.

Obě třídy mají dva základní typy locků: „čtecí“ a „zapisovací“ zámek (read lock, resp. write lock). Write lock zajišťuje vždy exkluzivní přístup k souboru, je tedy určen, překvapivě, k zapisování, zatímco jeden read lock je „kompatibilní“ s ostatními read locky, takže čtení ze souboru není omezené.

Jinak řečeno, vlákno, které momentálně má svůj write lock blokuje všechna ostatní vlákna, která se pokusí získat vlastní write nebo read (!) lock. Ale pokud žádné vlákno zrovna write lock nemá, může získat read lock libovolný počet vláken.

Třída ReaderWriterLockSlim má následující metody, které slouží k zamykání a odemykání pomocí read/write locků:

public void EnterReadLock();
public void ExitReadLock();
public void EnterWriteLock();
public void ExitWriteLock();

Ještě existují „Try“ verze obou „EnterXXX“ metod (například TryEnterReadLock), které přijímají číselný argument určující, jak dlouho má vlákno čekat na získání zámku. (Vzpomínáte si ještě na Monitor.TryEnter? Ten funguje také tak.) Starý ReaderWriterLock má podobné metody, pojmenované „AcquireXXX“ (místo „EnterXXX“) a ReleaseXXX (místo „ExitXXX“).

Následující příklad ukazuje ReaderWriterLockSlim v praxi. Tři vlákna neustále procházejí kolekci, zatímco dvě další vlákna každou vteřinou přidají do této kolekce nějaké náhodné číslo. Díky exkluzivnímu přístupu ke kolekci se nestane, že by obě zapisovací vlákna přidala číslo najednou.

class SlimDemo
{
    static ReaderWriterLockSlim rw = new ReaderWriterLockSlim();
    static List<int> items = new List<int>();
    static Random rand = new Random();

    static void Main()
    {
        new Thread(Read).Start();
        new Thread(Read).Start();
        new Thread(Read).Start();

        new Thread(Write).Start("A");
        new Thread(Write).Start("B");
    }

    static void Read()
    {
        while (true)
        {
            rw.EnterReadLock();
            foreach (int i in items) Thread.Sleep(10);
            rw.ExitReadLock();
        }
    }

    static void Write(object threadID)
    {
        // V nekonečné smyčce zapisuje do kolekce
        while (true)
        {
            int newNumber = GetRandNum(100); // Vygenerované číslo
            rw.EnterWriteLock(); // Před zápisem získá exkluzivní lock
            items.Add(newNumber);
            rw.ExitWriteLock(); // "Odemkne" kolekci pro ostatní vlákna
            Console.WriteLine("Vlákno " + threadID + " přidalo číslo " + newNumber);
            Thread.Sleep(100);
        }
    }

    static int GetRandNum(int max)
    {
        // Vygeneruje číslo
        lock (rand) return rand.Next(max);
    }
}

Ve skutečném kódu byste ještě měli přidat try/catch bloky, abyste zajistili, že zámek bude skutečne odemčen, i kdyby se vyskytla nějaká výjimka.

Právě demonstrovaná třída umožňuje zjišťování mnohem víc informací, než by dovolil obyčejný lock. Přidejte například do metody Write tento kód na začátek while smyčky:

Console.WriteLine("Právě čtou " + rw.CurrentReadCount + " vlákna");

Jak už jste asi uhodli, CurrentReadCount vrací počet vláken, která jsou momentálně pod read lockem. Většinou bude vypisovat: „Právě čtou 3 vlákna“, protože všechna tři vlákna tráví nejvíce času ve foreach smyčce. Kromě této vlastnosti obsahuje třída ReaderWriterLockSlim několik dalších:

public bool IsReadLockHeld            { get; }
public bool IsUpgradeableReadLockHeld { get; }
public bool IsWriteLockHeld           { get; }

public int  WaitingReadCount          { get; }
public int  WaitingUpgradeCount       { get; }
public int  WaitingWriteCount         { get; }

public int  RecursiveReadCount        { get; }
public int  RecursiveUpgradeCount     { get; }
public int  RecursiveWriteCount       { get; }

Někdy může být užitečné prohodit read lock za write lock a vytvořit tak jednu atomickou operaci (atomická operace je ta, která nejde přerušit). Například, pokud byste chtěli přidat prvek do nějaké kolekce, ale jen pod podmínkou, že daný prvek se ještě v kolekci nenachází. Postup by mohl být takovýto:

  1. Uzamknout kolekci pod read lockem.
  2. Zkontrolovat, jestli už prvek v kolekci je. Pokud ano, uvolnit zámek a zavolat return.
  3. Uvolnit zámek.
  4. Uzamknout kolekci pod write lockem.
  5. Zapsat prvek.

Problém při tomto postupu ale je, že jiné vlákno se může proplížit do této operace, zatímco jsou „odemčené“ všechny zámky a mezitím vložit stejný prvek jako ten, který už máme v plánu přidat (pokud se to stane těsně před uzavřením write locku, prvek se přidá dvakrát!). Třída ReaderWriterLockSlim ale naštěstí počítá i s tímto scénářem, a proto poskytuje třetí typ locku – tzv. upgradeable lock. Speciální druh zámku, který můžeme později nastavit na write lock. Celá operace je pak pod jedním velkým zámkem, jen se mění jeho povaha. Jiné vlákno tedy nemůže narušit práci. S využitím upgradeable locku bychom postupovali takto:

  1. Zavolat metodu EnterUpgradeableReadLock.
  2. Provést čtecí operace (kontrola, jestli už prvek v kolekci existuje).
  3. Zavolat metodu EnterWriteLock (změní upgradeable lock na write lock).
  4. Provést zapisovací operace (přidání prvku do kolekce).
  5. Zavolat metodu ExitWriteLock (změní write lock zpátky na upgradeable).
  6. Jakékoliv další operace čtecího charakteru.
  7. Zavolat metodu ExitUpgradeableReadLock.

V bodu 3 to funguje tak, že read lock se uvolní a vytvoří se zbrusu nový write lock tak, jako bychom to mohli udělat my sami, jen to celé probíhá atomicky (nenarušitelně).

Ještě jeden rozdíl mezi upgradeable a read locky by si zasloužil zmínku. Zatímco upgradeable lock může bez problémů koexistovat s libovolným počtem read locků, pouze jeden upgradeable lock může být v jednu chvíli aktivní.

Teď si ukážeme využití upgradeable locku na příkladu. Dělá přesně to, co jsme si popsali ve dvou postupech výše.

while (true)
{
    // newNumber = Nějaké číslo z pomocné metody
    int newNumber = GetRandNum (100);
    rw.EnterUpgradeableReadLock();
    if (!items.Contains (newNumber))
    {
        rw.EnterWriteLock();
        items.Add (newNumber);
        rw.ExitWriteLock();
        Console.WriteLine ("Vlákno " + threadID + " přidalo číslo " + newNumber);
    }
    rw.ExitUpgradeableReadLock();
    Thread.Sleep(100);
}

Rekurzivní lock

Na závěr dnešního dílu se jen krátce mrkneme na rekurzivní locking. Ve výchozí podobě je nějaké vložené nebo rekurzivní zamykání pomocí třídy ReaderWriterLockSlim zakázané. Takže tento kód se nezkompiluje:

var rw = new ReaderWriterLockSlim();
rw.EnterReadLock();
rw.EnterReadLock();
rw.ExitReadLock();
rw.ExitReadLock();

Pokud se ale vytvoří instance ReaderWriterLockSlim takto, vše půjde bez problémů:

var rw = new ReaderWriterLockSlim (LockRecursionPolicy.SupportsRecursion);

To, že musíme explicitně rekurzivní locking povolit zajišťuje, že k němu dojde tehdy, kdy to sami plánujeme:

rw.EnterWriteLock();
rw.EnterReadLock();
Console.WriteLine (rw.IsReadLockHeld);     // True
Console.WriteLine (rw.IsWriteLockHeld);    // True
rw.ExitReadLock();
rw.ExitWriteLock();

A zase máme díl za sebou. Tentokrát jsme probrali užitečnou třídu ReaderWriterLockSlim, zatímco příště nás čeká tzv. „thread pooling“, někdy překládaný jako „fond vláken“.

Zdroj: http://www.albahari.com/threading/part3.aspx#_ReaderWriterLock

×Odeslání článku na tvůj Kindle

Zadej svůj Kindle e-mail a my ti pošleme článek na tvůj Kindle.
Musíš mít povolený příjem obsahu do svého Kindle z naší e-mailové adresy kindle@programujte.com.

E-mailová adresa (např. novak@kindle.com):

TIP: Pokud chceš dostávat naše články každé ráno do svého Kindle, koukni do sekce Články do Kindle.

Hlasování bylo ukončeno    
0 hlasů
Google
Jakub studuje informatiku na FIT ČVUT, jeho oblíbenou platformou je .NET.
Web     Twitter     Facebook     LinkedIn    

Nové články

Obrázek ke článku Stavebnice umělé inteligence 1

Stavebnice umělé inteligence 1

Článek popisuje první část stavebnice umělé inteligence. Obsahuje lineární a plošnou optimalizaci.  Demo verzi je možné použít pro výuku i zájmovou činnost. Profesionální verze je určena pro vývojáře, kteří chtějí integrovat popsané moduly do svých systémů.

Obrázek ke článku Hybridní inteligentní systémy 2

Hybridní inteligentní systémy 2

V technické praxi využíváme často kombinaci různých disciplín umělé inteligence a klasických výpočtů. Takovým systémům říkáme hybridní systémy. V tomto článku se zmíním o určitém typu hybridního systému, který je užitečný ve velmi složitých výrobních procesech.

Obrázek ke článku Jak vést kvalitně tým v IT oboru: Naprogramujte si ty správné manažerské kvality

Jak vést kvalitně tým v IT oboru: Naprogramujte si ty správné manažerské kvality

Vedení týmu v oboru informačních technologií se nijak zvlášť neliší od jiných oborů. Přesto však IT manažeři čelí výzvě v podobě velmi rychlého rozvoje a tím i rostoucími nároky na své lidi. Udržet pozornost, motivaci a efektivitu týmu vyžaduje opravdu pevné manažerské základy a zároveň otevřenost a flexibilitu pro stále nové výzvy.

Obrázek ke článku Síla týmů se na home office může vytrácet. Odborníci radí, jak z pracovních omezení vytěžit maximum

Síla týmů se na home office může vytrácet. Odborníci radí, jak z pracovních omezení vytěžit maximum

Za poslední rok se podoba práce zaměstnanců změnila k nepoznání. Především plošné zavedení home office, které mělo být zpočátku jen dočasným opatřením, je pro mnohé už více než rok každodenní realitou. Co ale dělat, když se při práci z domova ztrácí motivace, zaměstnanci přestávají komunikovat a dříve fungující tým se rozpadá na skupinu solitérů? Odborníci na personalistiku dali dohromady několik rad, jak udržet tým v chodu, i když pracovní podmínky nejsou ideální.

Hostujeme u Českého hostingu       ISSN 1801-1586       ⇡ Nahoru Webtea.cz logo © 20032024 Programujte.com
Zasadilo a pěstuje Webtea.cz, šéfredaktor Lukáš Churý