Wprowadzenie do wielowątkowości w C #

Aby zrozumieć wielowątkowość w c #, najpierw zrozummy, co to jest wątek?

  • Wątek jest procesem lekkim.
  • Jest to ścieżka wykonania programu.
  • Jest to najmniejsza jednostka przetwarzania w systemie operacyjnym.
  • W ten sposób proces może mieć wiele wątków.

Tak więc wielowątkowość to proces zawierający wiele wątków, w których każdy wątek wykonuje inną czynność. Oszczędza czas, ponieważ wiele zadań jest wykonywanych jednocześnie przez różne wątki. Zwiększa wykorzystanie procesora i zwiększa wydajność aplikacji. Działa to na zasadzie podziału czasu.

Składnia z wyjaśnieniem

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();

Aby utworzyć wątek, musimy utworzyć obiekt klasy Thread. Konstruktor klasy Thread odwołuje się do ThreadStart. ThreadStart jest delegatem reprezentującym metodę, którą należy wykonać, gdy wątek rozpocznie wykonywanie.

Wątek rozpoczyna wykonywanie po wywołaniu metody Start ().

Możemy utworzyć wątek bez użycia delegata ThreadStart, jak pokazano w poniższej składni:

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

Tworzenie wielu wątków w C #

Aby utworzyć wątki, musimy zaimportować system. Przestrzeń nazw wątków. Możemy tworzyć i inicjować wątki za pomocą klasy Thread.

Przykład użycia klasy wątku

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();
)
)

Wynik:

Przykład użycia delegata 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();
)
)

Wynik:

Uwaga: Nie jest konieczne, aby metody stosowane w wielowątkowości były statyczne, jak w dwóch powyższych przykładach, obie metody tj. Metoda 1 i Metoda 2 są statyczne. Metody te mogą być niestatyczne i w takim przypadku najpierw musimy utworzyć obiekt klasy zawierający metody, a następnie uzyskać dostęp do metod za pomocą obiektu.

W języku C # program zawsze zawiera jeden wątek, tj. Wątek główny. Kiedy tworzymy inne wątki, staje się to programem wielowątkowym, aw C # wielowątkowym istnieją dwa typy wątków:

  • Wątek pierwszego planu : Wątek ten jest wykonywany do momentu zakończenia pracy, nawet jeśli główny wątek się zakończy.
  • Wątek w tle : po zakończeniu wątku głównego wątek w tle również przestaje działać i kończy się wraz z wątkiem głównym.

Metody z przykładami

Zobaczmy niektóre często używane metody klasy Thread z przykładami.

  • Sleep (): Służy do wstrzymania wykonywania bieżącego wątku na określony czas, aby inne wątki rozpoczęły wykonywanie.

Przykład:

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();
)
)

Wynik:

Dane wyjściowe pokazują, że oba wątki są wykonywane równolegle.

  • Abort (): Służy do zakończenia wątku lub możemy powiedzieć, że służy do trwałego zatrzymania wykonywania wątku.

Przykład

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());
)
)
)

Wynik:

  • Join (): Używane, aby wszystkie wątki wywołujące czekały, aż bieżący wątek zakończy wykonywanie i zakończy działanie.

Przykład:

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();
)
)

Wynik:

Zalety wielowątkowości w C #

  1. Pomaga w utrzymaniu responsywnego interfejsu użytkownika: Czasami w naszej aplikacji mamy czasochłonną metodę. W takim przypadku, jeśli wykonamy naszą aplikację wielowątkową, wówczas inny wątek bierze odpowiedzialność za wykonanie tej metody, podczas gdy wątek główny może skupić się na responsywności aplikacji. W ten sposób nie zamrozi naszej aplikacji, udzielając w odpowiednim czasie właściwej odpowiedzi użytkownikowi.
  2. Zwiększa wydajność aplikacji: jeśli mamy tyle wątków, ile jest rdzeni procesorów, każdy wątek będzie działał niezależnie, zwiększając liczbę obliczeń na sekundę.
  3. Wątki minimalizują wykorzystanie zasobów systemowych, ponieważ współużytkują tę samą przestrzeń adresową.
  4. To sprawia, że ​​kod jest jednocześnie szybszy i prostszy.

Wniosek - wielowątkowość w C #

Klasa wątków zapewnia wiele ważnych właściwości, takich jak Priority, Name, IsAlive, tło, które możemy wykorzystać w naszej aplikacji wielowątkowej. Synchronizacja wątków to technika, dzięki której wątek może uzyskać dostęp do zasobu przez określony czas bez przerywania działania innych wątków, dopóki nie zakończy swojego zadania.

Polecane artykuły

To był przewodnik po wielowątkowości w C #. Tutaj omawiamy również ich wprowadzenie, składnię, tworzenie i przykłady wielowątkowości w c #. Możesz także zapoznać się z następującymi artykułami, aby dowiedzieć się więcej -

  1. Obiekty w C #
  2. Niszczyciel w C #
  3. Niszczyciel w C #
  4. Dziedziczenie w C #
  5. Destructor w PHP | Przykłady

Kategoria:

Rozwój oprogramowania