Introducere în Multithreading în C #

Pentru a înțelege multitreading în c #, să înțelegem mai întâi ce este un thread?

  • Un fir este un proces de greutate ușoară.
  • Este o cale de execuție a unui program.
  • Este cea mai mică unitate de procesare dintr-un sistem de operare.
  • Astfel, un proces poate avea mai multe fire.

Deci, multithreading este un proces care conține mai multe fire în care fiecare thread realizează o activitate diferită. Economisește timp, deoarece mai multe sarcini sunt executate în același timp de diferite fire. Crește utilizarea procesorului și crește eficiența unei aplicații. Aceasta funcționează pe conceptul de distribuire a timpului.

Sintaxa cu explicație

Thread first_thread_name = new Thread(new ThreadStart(method_to_be_executed1));
Thread second_thread_name = new Thread(new ThreadStart(method_to_be_executed2));
first_thread_name.Start();
second_thread_name.Start();

Pentru a crea un thread, trebuie să creăm un obiect din clasa Thread. Constructorul clasei Thread ia referință la ThreadStart. ThreadStart este un delegat care reprezintă o metodă care trebuie executată atunci când thread-ul începe executarea.

Firul începe executarea atunci când este apelată metoda Start ().

Putem crea un thread fără a utiliza delegatul ThreadStart așa cum se arată în sintaxa de mai jos:

Thread thread_name = new Thread(method_to_be_executed);
thread_name.Start();

Crearea mai multor fire în C #

Pentru a crea thread-uri, trebuie să importăm sistem.Threading namespace. Putem crea și inițializa thread-uri folosind clasa Thread.

Exemplu folosind clasa Thread

using System;
using System.Threading;
public class MultiThreadingDemo
(
public static void Method1()
(
for (int i = 0; i <= 5; i++)
(
Console.WriteLine("Method1 : (0)", i);
)
)
public static void Method2()
(
for (int i = 0; i <= 5; i++)
(
Console.WriteLine("Method2 : (0)", i);
)
)
public static void Main()
(
// Creating and initializing threads
Thread thread1 = new Thread(Method1);
Thread thread2 = new Thread(Method2);
//beginning thread execution
thread1.Start();
thread2.Start();
)
)

ieşire:

Exemplu folosind delegatul ThreadStart

using System;
using System.Threading;
public class MultiThreading
(
public static void Method1()
(
for (int i = 1; i <= 5; i++)
(
Console.WriteLine("Method1 : (0)", i);
)
)
public static void Method2()
(
for (int i = 1; i <= 5; i++)
(
Console.WriteLine("Method2 : (0)", i);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Thread thread1 = new Thread(new ThreadStart(MultiThreading.Method1 ) );
Thread thread2 = new Thread(new ThreadStart(MultiThreading.Method2 ) );
thread1.Start();
thread2.Start();
)
)

ieşire:

Notă: Nu este necesar ca metodele utilizate în multitrare să fie statice ca în cele două exemple de mai sus, ambele metode adică Metoda 1 și Metoda2 sunt statice. Aceste metode pot fi nestatice și, în acest caz, trebuie mai întâi să creăm un obiect al clasei care conține metode și apoi să putem accesa metodele folosind obiectul.

În C #, un program conține întotdeauna un fir, adică filet principal. Când creăm alte thread-uri, devine un program multithreading și în C # multithreading, există două tipuri de fire:

  • Fișă în prim plan : Acest thread continuă să se execute până când își termină activitatea, chiar dacă firul principal se încheie.
  • Filet de fundal : Când se încheie firul principal, firul de fundal nu mai execută și se termină cu firul principal.

Metode cu exemple

Să vedem câteva metode utilizate în mod obișnuit din clasa Thread, cu exemple.

  • Sleep (): Folosit pentru a întrerupe execuția firului curent pentru o anumită perioadă de timp, astfel încât alte fire să înceapă execuția.

Exemplu:

using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 1; i <= 10; i++)
(
Console.WriteLine(i);
//suspending execution of current thread for 100 milliseconds
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
thread1.Start();
thread2.Start();
)
)

ieşire:

Rezultatul arată că ambele fire executate în paralel.

  • Abort (): Folosit pentru a încheia firul sau putem spune că este folosit pentru a opri executarea firului permanent.

Exemplu

using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 0; i < 10; i++)
(
Console.WriteLine(i);
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
Console.WriteLine("Threads start execution");
thread1.Start();
thread2.Start();
try
(
//terminating execution of thread using Abort()
thread1.Abort();
thread2.Abort();
Console.WriteLine("Threads execution terminated");
)
catch (ThreadAbortException threadAbortException)
(
Console.WriteLine(threadAbortException.ToString());
)
)
)

ieşire:

  • Alăturați-vă (): utilizat pentru a face ca toate firele apelante să aștepte până când firul curent își termină execuția și se încheie.

Exemplu:

using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 0; i < 5; i++)
(
Thread thread = Thread.CurrentThread;
Console.WriteLine(thread.Name +" : "+i);
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
Thread thread3 = new Thread(new ThreadStart(multithreading.Display));
//Assigning names to threads using Name property
thread1.Name = "Thread1";
thread2.Name = "Thread2";
thread3.Name = "Thread3";
thread1.Start();
//Making Thread2 and Thread3 wait until Thread1 completes execution
thread1.Join();
thread2.Start();
thread3.Start();
)
)

ieşire:

Avantajele multitreading în C #

  1. Ajută la menținerea unei interfețe de utilizator responsive: Uneori avem o metodă consumatoare de timp în aplicația noastră. În acest caz, dacă facem aplicația noastră multitratată, atunci alt thread își asumă responsabilitatea pentru execuția acelei metode, în timp ce thread-ul principal se poate concentra pe receptivitatea aplicației. Astfel, nu va îngheța aplicația noastră dând un răspuns adecvat utilizatorului.
  2. Crește performanța aplicației: Dacă avem atâtea fire cât sunt nuclee de procesor, fiecare fir va rula independent crește numărul de calcule pe secundă.
  3. Firele reduc la minimum utilizarea resurselor de sistem, deoarece au același spațiu de adrese.
  4. Face codul mai rapid și mai simplu în același timp.

Concluzie - Multithreading în C #

Clasa Thread oferă multe proprietăți importante precum Priority, Name, IsAlive, fundal pe care îl putem folosi în aplicația noastră multithreading. Sincronizarea firelor este o tehnică prin care un thread poate accesa o resursă pentru o anumită perioadă de timp, fără întreruperea altor fire, până când își termină sarcina.

Articole recomandate

Acesta a fost un ghid pentru Multithreading în C #. Aici vom discuta, de asemenea, introducerea lor, sintaxa, crearea și exemple de multithreading în c #. De asemenea, puteți arunca o privire asupra articolelor următoare pentru a afla mai multe -

  1. Obiecte din C #
  2. Distrugător în C #
  3. Distrugător în C #
  4. Moștenire în C #
  5. Distrugător în PHP | Exemple

Categorie:

Dezvoltare de software