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

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“.