fire de executie 3

Despre fire de executie in c# (threads)

   De multe ori, aplicatiile au nevoie de mult timp pentru a rezolva o sarcina (descarcarea unui fisier, printare, generarea unui raport etc), timp in care programul nu poate raspunde unei alte actiuni a utilizatorului. Pentru a face ca o aplicatie sa indeplineasca o sarcina si sa poata primi si altele in acelasi timp, sunt folosite firele de executie multiple (multiple threads).

   Intr-un program liniar se executa o singura linie de cod, se asteapta pentru completare si apoi se continua cu urmatoarea linie de cod.  Programul nu poate raspunde actiunii unui utilizator in acest timp si chiar in cazul mai multor procesoare, va fi folosit doar unul singur, limitand performanta, datorita programarii single-thread.

   Un fir de executie (thread) este un program secvential, care poate fi executat concurent cu alte fire. Un thread este o unitate de executie intr-un proces. Un proces poate avea mai multe fire de executie, el numindu-se multithread. Daca un calculator are mai multe  procesoare sau un procesor cu mai multe nuclee, el poate executa mai multe fire de executie simultan.

   Diferenta dintre un proces si un thread este ca procesele sunt izolate total unul de celalalt, in timp ce thread-urile impart aceeasi memorie (heap) cu alte thread-uri care ruleaza in aceeasi aplicatie (un thread poate prelua informatii noi, in timp ce un alt thread le prelucreaza pe cele existente).

   Folosirea firelor de executie este o solutie la imbunatatirea performantei. Se cere insa foarte multa atentie la folosire. Scrierea unui cod multithread este complexa, iar problemele care pot aparea pot fi foarte greu de rezolvat.

   Un fir de executie, thread, poate avea mai multe stari.

    Trecerea de la starea gata de executare la starea in curs de executare are loc cand un procesor il alege pentru executare. La terminare, trece in starea terminat.

   Un proces în curs de executare poate fi suspendat (amanat sau blocat), dupa care poate reveni în substarea gata de executare.

    – amânat: inseamna întreruperea executarii procesului un anumit timp, în urma apelarii procedurii predefinite sleep; aceasta procedura are un singur parametru de tip întreg.

   - blocat: inseamna întreruperea executarii procesului pe baza unei relatii (comunicari) cu alte procese; procesul poate reveni ulterior în starea gata de executare pe o baza similara.Esential in folosirea firelor de executie multiple este evitarea conflictelor de resurse, cand vor trebuie blocate anumite resurse, pentru a putea fi folosite de catre un singur fir de executie, pe rand.

    Cel mai simplu mod de a crea un thread este sa instantiem un obiect Thread, al carui constructor va cere ca parametru un delegate de tipul ThreadStart. Delegatul va indica ce metoda va rula in thread.

Adaugam namespace-ul, mai intai:

    using System.Threading;

Exemplu pentru un simpu thread:

    class Numara
    {
        //numara pana la 10
        public void Zece()
        {
            Console.WriteLine("Simple Thread");
            for (int i = 0; i <= 10; i++)
            {
                Console.WriteLine(i);
            }
        }
    }

in Main:

    Numara numara = new Numara();
    //obiectul Thread
    Thread thread1 = new Thread (new ThreadStart(numara.Zece));
    threaUnu.Start(); 

   Codul de mai sus nu reflecta puterea firelor de executie multiple, pentru ca avem doar unul. O sa adaugam inca un thread, o sa setam numele pentru o identificare mai usoara si vom folosi proprietatea CurrentThread care va returna firul de executie curent.

    //obiectul Thread
    Thread thread1 = new Thread (new ThreadStart(numara.Zece));
    Thread thread2 = new Thread(new ThreadStart(numara.Zece));

    thread1.Name = "Thread One";
    thread2.Name = "Thread Two";

    thread1.Start();
    thread2.Start();
 
    public void Zece()
    {
        for (int i = 0; i <= 10; i++)
        {
            Console.WriteLine("{0},numara :{1}",Thread.CurrentThread.Name,i);
        }
    }

   Exemplul complet, de la sfarsitul articolului, va contine cod care va arata cum thread-urile apeleaza metode diferite.

   Cand trebuie sa declaram mai multe fire de executie, putem construi un vector de fire de executie.

    Thread[] threads = 
    {
        new Thread(new ThreadStart(numara.Zece)),
        new Thread(new ThreadStart(numara.Zece))
    };

Metoda Sleep

   Se foloseste atunci cand vrem sa suspendam un fir de executie, pentru o anumita perioada.

Exemplu:

Intr-una din metodele de mai sus adaugam :

    Thread.Sleep(5000);

Metoda primeste ca parametri un integer care reprezinta numarul milisecundelor cat va fi suspendat firul de executie.

Metoda Join

   Presupunem ca suntem in situatia cand vrem ca un thread sa astepte un alt thread sa isi termine executia, inainte ca thread-ul nostru curent sa continue.

    //se va merge mai departe cu executia programului
    //dupa terminararea celor trei fire de executie
    thread1.Join();
    thread2.Join();
    thread3.Join();

Metoda Abort

   Se foloseste atunci cand vrem sa oprim (“kill”) un fir de executie.

    //thread2 a fost oprit
    thread2.Abort();

Proprietatea Priority

   Folosind aceasta proprietate, se poate determina ce timp de executie are un thread in comparatie cu alte threaduri active din acelasi proces:

    enum ThreadPriority { Lowest, BelowNormal, Normal, AboveNormal, Highest }

   In lucrul cu multithreading-ul apare o problema majora, cea a sincronizarii: mai multe fire de executii acceseaza acelasi obiect, simulan. Solutia vine de la “lock”: atunci cand primul thread acceseaza obiectul, il va tine “ocupat” pana la incheiere.

   Folosirea firelor de executie permite rularea proceselor simultan, dar acest lucru poate incetini executia programului, daca nu sunt folosite cu atentie.

   O aplicatie C# poate deveni multi-threading in doua moduri: fie explicit prin crearea si rularea firelor de executie, fie prin folosirea unor caracteristici ale .Net care creeaza implicit thread-uri: BackgroundWorker, thread pooling sau la construirea unui Web Service sau unei aplicatii Asp.Net.