Dnes se podíváme na zoubek synchronizaci aneb jak donutit vlákna, aby dělala co chceme, kdy chceme.

Synchronizace, jak název napovídá, slouží ke zkoordinování práce jednotlivých vláken. Následuje několik tabulek, které popisují jednotlivé prostředky k synchronizaci.

Jednoduché blokovací metody

„Zamykací“ konstrukce (locks)

Signalizační konstrukce

Neblokující konstrukce

Blokování

Pokud vlákno čeká, nebo je jeho práce zapauzována následkem některé z výše uvedených konstrukcí, říkáme o něm, že je zablokované. Jakmile je vlákno zablokováno, uvolní se všechny požadované CPU prostředky, do vlastnosti ThreadState se uloží hodnota WaitSleepJoin a v tomto stavu zůstává, dokud není odblokováno. K odblokování může dojít celkem čtyřmi způsoby (nepočítám vypnutí PC):

• dojde ke splnění blokovací podmínky,
• vypršením času, po který má být vlákno blokováno,
• přerušením pomocí Thread.Interrupt,
• zrušením blokování pomocí Thread.Abort.

Uspávání

Párkrát během seriálu jsem použil pojem „uspávání vlákna“, což je zablokování vlákna na zadaný čas pomocí metody Thread.Sleep (nebo do zavolání Thread.Interrupt).

static void Main()
{
    Thread.Sleep(0);                        // vypustí jeden time-slice
    Thread.Sleep(1000);                     // uspí na 1000 ms
    Thread.Sleep(TimeSpan.FromHours(1));    // uspí na 1 hodinu
    Thread.Sleep(Timeout.Infinite);         
        // uspí vlákno na nekonečně dlouho dobu (do zavolání Thread.Interrupt)
}

Třída Thread poskytuje i jednu spíše zajímavost. Tou je metoda SpinWait(), která po zavolání neuvolní prostředky CPU, ale naopak ho uzavře do cyklu na zadaný počet iterací. Padesát iterací odpovídá zhruba jedné mikrosekundě (opravdu jen zhruba, závisí to totiž na rychlost a vytížení procesoru). Říkejme pracovně takto zaměstnanému vláknu „zacyklené vlákno“ (oficiální česká terminologie neexistuje, tenhle název je čistě můj výmysl). SpinWait() není blokovací metoda, protože zacyklené vlákno nemá hodnotu WaitSleepJoin ve vlastnosti ThreadState, ani nemůže být přerušena pomocí metody Interrupt(). Metoda SpinWait() se využívá dost vzácně, její účel je při čekání na data, která mají přijít v horizontu mikrosekund. Takové čekání pomocí Sleep() je pak zbytečně náročné. Tento postup má ale smysl pouze u vícejádrových systémů, u jednojádrových se totiž rychleji ukončí time-slice pro aktuální vlákno a tím se ukončí i aktivita SpinWait(). Metodě popsané v tomto odstavci se také říká spinning.

Blokování vs. Spinning

Vlákno můžeme zacyklit i známým „trikem“ s while:

while (!proceed);

Tento postup je ale zbytečně náročný na procesor. CLR i operační systém jednoduše pořád dokola kontrolují hodnotu proměnné proceed. Úspornější variantou je takový hybrid mezi blokováním a spinningem:

while (!proceed) Thread.Sleep (x);

Čím větší má proměnná x hodnotu, tím je toto úspornější, protože se vlákno uspí a až po uplynutí času x se stav proměnné proceed zkontroluje znovu. Cokoliv nad 20 ms je už zase zbytečně přehnané, pokud není podmínka pro cyklus while zvlášť složitá, protože za těch 20 ms už se procesor uvolní pro další iteraci.

Metoda Join()

Dalším z mnoha postupů pro blokování je Join() metoda. Po zavolání zablokuje práci aktuálního vlákna, než jiné vlákno dodělá svojí práci. „Zneužiju“ tenhle příklad pro demonstraci lambda výrazů (když už máme ten .NET Framework 3.5).

class JoinDemo
{
    static void Main()
    {
        Thread t = new Thread(() => Console.ReadLine());
        t.Start();
        t.Join();    // Čekat, dokud vlákno 't' nedokončí práci
        Console.WriteLine("ReadLine vlákna 't' hotov");
    }
}

Tento kód je ekvivalentem k tomuto:

class JoinDemo
{
    static void Main()
    {
        Thread t = new Thread(delegate() { Console.ReadLine(); });
        t.Start();
        t.Join();    // Čekat, dokud vlákno 't' nedokončí práci
        Console.WriteLine("ReadLine vlákna 't' hotov");
    }
}

Join() přijímá jeden parametr typu TimeSpan v milisekundách. Pokud vyprší čas dříve, než se ukončí práce zadaného vlákna, metoda vrátí false. S využitím tohoto parametru funguje metoda Join() podobně jako Sleep():

Thread.Sleep (1000);
Thread.CurrentThread.Join (1000);

A jsme na konci dalšího dílu, příště nás čeká podrobněji probraná problematika zamykání (locking) a thread safety.