Cum se utilizează mai multe filetări cu sarcini în C #

Termenul de programare computer "thread" este scurt pentru thread de execuție, în care un procesor urmează o cale specificată prin codul dvs. Conceptul de a urma mai mult de un thread simultan introduce subiectul multi-tasking și multi-threading.

O aplicație are unul sau mai multe procese în ea. Gândiți-vă la un proces ca la un program care rulează pe computer. Acum, fiecare proces are unul sau mai multe fire. O aplicație de joc ar putea avea un fir pentru a încărca resurse de pe disc, alta pentru a face AI și alta pentru a rula jocul ca server.

În .NET / Windows, sistemul de operare alocă timp procesorului unui thread. Fiecare thread urmărește gestionarea excepțiilor și prioritatea la care rulează și are undeva să salveze contextul thread până când rulează. Contextul firelor este informația pe care firul trebuie să o reia.

Multi-sarcini cu fire

Firele preiau un pic de memorie și crearea lor durează puțin, așa că, de obicei, nu vrei să folosești multe. Amintiți-vă, ei concurează pentru timpul procesorului. Dacă computerul are mai multe procesoare, atunci Windows sau .NET ar putea rula fiecare thread pe un procesor diferit, dar dacă mai multe fire rulează pe același procesor, doar unul poate fi activ la un moment dat și comutarea firelor necesită timp..

CPU procesează un thread pentru câteva milioane de instrucțiuni, apoi trece la un alt thread. Toate registrele CPU, punctul de execuție și stiva actuală a programului trebuie salvate undeva pentru primul thread și apoi restabilite din altă parte pentru următorul thread.

Crearea unui fir

În Sistemul de spații de nume. Filetarea, veți găsi tipul de fir. Firul constructor (ThreadStart) creează o instanță a unui thread. Cu toate acestea, în codul C # recent, este mai probabil să treceți într-o expresie lambda care apelează metoda cu orice parametri.

Dacă nu sunteți sigur de expresiile lambda, ar putea merita să consultați LINQ.

Iată un exemplu de thread creat și pornit:

folosind Sistem;

folosind System.Threading;
spațiu de nume ex1

Programul clasei

public static void Write1 ()

Console.Write ('1');
Thread.Sleep (500);

static void Main (string [] args)

var task = new Thread (Write1);
task.Start ();
for (var i = 0; i < 10; i++)

Console.Write ('0');
Console.Write (task.IsAlive? 'A': 'D');
Thread.Sleep (150);

Consola.ReadKey ();

Tot acest exemplu este să scrieți „1” în consolă. Firul principal scrie un "0" consolei de 10 ori, de fiecare dată urmat de un "A" sau "D", în funcție de faptul că celălalt fir este încă viu sau mort.

Celălalt thread rulează o singură dată și scrie un „1.” După o întârziere de jumătate de secundă în firul Write1 (), firul se termină, iar Task.IsAlive din bucla principală revine acum "D."

Biblioteca de fire și bibliotecă paralelă cu activități

În loc să-ți creezi propriul thread, cu excepția cazului în care ai nevoie într-adevăr să faci asta, folosește un pool de fire. De la .NET 4.0, avem acces la biblioteca paralelă cu activități (TPL). Ca și în exemplul anterior, din nou avem nevoie de un pic de LINQ și, da, este vorba de expresii lambda.

Tasks folosește Thread Pool în spatele scenei, dar utilizează mai bine firele în funcție de numărul utilizat.

Obiectul principal din TPL este o Sarcină. Aceasta este o clasă care reprezintă o operație asincronă. Cea mai obișnuită modalitate de a porni lucrările rulând este cu Task.Factory.StartNew ca în: