Wielowątkowość w języku C#: korzyści, podstawy i najlepsze praktyki

Co to jest programowanie wielowątkowe

Wielowątkowość jest fundamentalną koncepcją inżynierii oprogramowania. W języku C# programowanie wielowątkowe jest niezbędne dla programistów pracujących z platformą .NET Framework. Deweloperzy powszechnie używają wielowątkowości w języku C# , ponieważ pozwala im to wydajnie tworzyć złożone i responsywne aplikacje.

Ten blog zawiera omówienie wielowątkowości języka C#, a jednocześnie pokazuje, jak programiści mogą łatwo tworzyć wątki i zarządzać nimi. Obejmuje również zalety korzystania z wielowątkowości i różnych modeli wątków dostępnych w języku C#.

Korzyści i zalety programowania wielowątkowego

Wykonywana jednocześnie wielowątkowość poprawia efektywność aplikacji. Do najczęstszych zalet wątku C# należą:

• Zwiększona wydajność aplikacji: dzięki wielowątkowości aplikacje działają szybciej, a wiele zadań działa w tej samej przestrzeni.W sumie skraca czas wykonania i ustępuje wielu zadaniom.
• Zwiększona przepustowość: wielozadaniowość w języku C# zwiększa przepustowość aplikacji.Gdy dwa różne wątki działają jednocześnie, może to zaoszczędzić czas i zasoby.
• Poprawiona responsywność: za pomocą wielowątkowości użytkownik może uzyskać dostęp do interfejsu aplikacji, podczas gdy program działa w tle.
• Zwiększone wykorzystanie zasobów: wielowątkowość umożliwia użytkownikom bardziej efektywny dostęp do zasobów systemowych.Na przykład wątki mogą współdzielić zasoby, takie jak pliki, pamięć i urządzenia we/wy, torując drogę do wydajności.
• Bardziej przystępne programowanie: wielowątkowość umożliwia łatwiejsze programowanie, ponieważ użytkownicy mogą niezależnie pisać wątki.Umożliwia także użytkownikom debugowanie i testowanie aplikacji w izolacji.
• Zoptymalizowana komunikacja: Synchronizacja wątków umożliwia lepszą komunikację między procesami.Może być używany do bardziej przystępnej komunikacji między wątkami.

Po pierwsze dotyczy pojedynczych obiektów, które można zsynchronizować. Po drugie, może być używany z klasami System.Threading i Interlocked.

Podstawowe koncepcje wielowątkowości w języku C#

Wielowątkowość umożliwia użytkownikom wykonywanie wielu zadań jednocześnie przy pomocy wielu rdzeni procesora. Oto podstawowe pojęcia używane w wielowątkowości:

• Wątki: Wątki to podstawowe jednostki w wielowątkowości, które pomagają wykonać proces.Są to ścieżki wykonania w ramach danego programu, które mogą działać równolegle z innymi wątkami.

W języku C# możemy znaleźć dwa rodzaje wątków, a mianowicie wątki pierwszego planu i wątki tła. Średnia klasa wątku obejmuje nazwę, priorytet, isAlive, ThreadState, Start(), Suspend(), Resume() i Join().

• Pula wątków: Pula wątków to wątek, który pomaga wykonywać zadania.Pozwala systemowi operacyjnemu na ponowne wykorzystanie istniejących wątków i minimalizuje ryzyko ewentualnych kosztów ogólnych.
• Synchronizacja: Synchronizacja pomija dostęp do innych wątków dla wielu operacji.Jest to niezbędny proces do utrzymania integralności danych i zapobiegania narzutom.
• Zakleszczenie: Zakleszczenie to błąd występujący, gdy dwa wątki współdzielą zasoby i próbują kontynuować bez powodzenia.Może to spowodować zawieszenie systemu lub nawet wydłużenie czasu oczekiwania.
• Programowanie asynchroniczne: programowanie asynchroniczne umożliwia uruchamianie wielu zadań w tle, pozwalając jednocześnie na nieprzerwane działanie głównego wątku.To toruje drogę wielu responsywnym interfejsom użytkownika, zwiększając wydajność aplikacji.

Tworzenie i prowadzenie wątków

Dzięki tym przykładom tworzenie i uruchamianie może być łatwiejsze. Przykład wielowątkowości C# podano poniżej:

przy użyciu Systemu;

przy użyciu System.Threading;

program zajęć {

static void Main() {

int Indeks_pracownika = 0;

Wątek roboczy wątku = nowy wątek (nowy Początek wątku (pracownik));

wątek_roboczy.Start();

for (int mainIndex = 1; mainIndex <= 10; mainIndex++) {

Console.WriteLine("Główny wątek: {0}", mainIndex);

Wątek.Sleep(200);

}

wątek roboczy.Join();

}

static void Pracownik() {

for (int Indekspracownika = 1;Indekspracownika <= 10;Indekspracownika++) {

Console.WriteLine("Wątek roboczy: {0}", workerIndex * 2);

Wątek.Sleep(200);

}

}

}

Wyjście:

Główny wątek: 1

Wątek roboczy: 2

Główny wątek: 2

Wątek roboczy: 4

Główny wątek: 3

Wątek roboczy: 6

Główny wątek: 4

Wątek roboczy: 8

Główny wątek: 5

Wątek roboczy: 10

Główny wątek: 6

Wątek roboczy: 12

Główny wątek: 7

Wątek roboczy: 14

Główny wątek: 8

Wątek roboczy: 16

Główny wątek: 9

Wątek roboczy: 18

Główny wątek: 10

Wątek roboczy: 20

Objaśnienie: W tym wyjściu oba wątki działają jednocześnie, aby wydrukować liczby od 1 do 10 i od 2 do 20, te ostatnie podwoiły się z indeksu pętli.W tym przykładzie użyto metody uśpienia wątku języka C# (Thread.Sleep).

W ten sam sposób przyjrzymy się innemu przykładowi wątku C# z użyciem wątku pierwszoplanowego:

przy użyciu Systemu;

przy użyciu System.Threading;

program zajęć {

static void Main() {

Wątek mój wątek = nowy wątek (pracownik);

mójWątek.Start();

Console.WriteLine("Główny wątek: rozpoczęty");

for (int i = 1; i <= 5; i++) {

Console.WriteLine("Główny wątek: liczba {0}", i);

Wątek.Sen(500);

}

Console.WriteLine("Główny wątek: zakończony");

}

static void Pracownik() {

dla (w j = 1; j <= 5; j++) {

Console.WriteLine("Wątek roboczy: liczba {0}", j * 3);

Wątek.Sen(750);

}

Console.WriteLine("Wątek roboczy: zakończony");

}

}

Wyjście:

Główny wątek: Rozpoczęty

Wątek roboczy: liczba 3

Główny wątek: Policz 1

Wątek roboczy: liczba 6

Główny wątek: Policz 2

Wątek roboczy: policz 9

Główny wątek: Policz 3

Wątek roboczy: policz 12

Główny wątek: Policz 4

Wątek roboczy: policz 15

Główny wątek: Policz 5

Wątek roboczy: zakończony

Główny wątek: zakończony

Objaśnienie: Dane wyjściowe pokazują współbieżne działanie dwóch wątków.Ponieważ wątki główny i pomocniczy działają równolegle, główny wątek drukuje liczby od 1 do 5. Wątek roboczy drukuje wielokrotności od 3 do 15.

Sprawdź kursy tworzenia oprogramowania na stronie upGrad to upskill.

Przeczytaj nasze popularne artykuły związane z tworzeniem oprogramowania

Synchronizacja wątków

Synchronizacja wątków polega na zbiorowej koordynacji wielu wątków w programie. Zapewnia wykonanie programu w określonej kolejności dając dostęp do współdzielonych zasobów.

W języku C# odbywa się to za pomocą prymitywów synchronizacji, takich jak słowo kluczowe lock, obiekty synchronizacji i klasa Interlocked.

Poniżej podano przykład synchronizacji wątków C# :

Korzystanie z systemu;

Korzystanie z System.Threading;

klasa TablePrinter

{

public void PrintTable()

{

zablokować (to)

{

dla (int i = 3; i <= 8; i++)

{

Wątek.Sleep(200);

Console.WriteLine(i*5);

}

}

}

}

Program klasowy

{

public static void Main(string[] args)

{

Drukarka Tabeli tp = nowa Drukarka Tabeli();

Wątek t1 = nowy Wątek(nowy WątekStart(tp.PrintTable));

Wątek t2 = nowy Wątek(nowy WątekStart(tp.PrintTable));

t1.Start();

t2.Start();

}

}

Wyjście:

15

20

25

30

35

40

45

50

55

60

Zapoznaj się z naszymi bezpłatnymi kursami tworzenia oprogramowania

Zakleszczenia

Zakleszczenia w wielowątkowości mają miejsce, gdy co najmniej dwa lub więcej wątków zależy od zestawu zasobów. Gdy jeden wątek nakłada się na trasę do pomocy, podczas gdy drugi próbuje zrobić to samo, dochodzi do impasu.

Na przykład, jeśli wątek A ma blokadę na zasobie 1 i czeka na dostęp do zasobu 2, podczas gdy wątek B oczekuje na zasób 1, może to spowodować zakleszczenie.

Poniżej podano przykład:

przy użyciu Systemu;

przy użyciu System.Threading;

impas w przestrzeni nazwincsharp

{

klasa publiczna Przykład

{

statyczny obiekt tylko do odczytu firstLock = nowy obiekt ();

statyczny obiekt tylko do odczytu secondLock = nowy obiekt ();

static void ThreadJob()

{

Console.WriteLine("\t\t\t\tLocking firstLock");

zamek (pierwszy zamek)

{

Console.WriteLine("\t\t\t\tLocked firstLock");

Wątek.Sen(1500);

Console.WriteLine("\t\t\t\tLocking secondLock");

zamek (drugi zamek)

{

Console.WriteLine("\t\t\t\tZablokowana druga blokada");

}

Console.WriteLine("\t\t\t\tZwolniono drugą blokadę");

}

Console.WriteLine("\t\t\t\tZwolniono pierwszą blokadę");

}

static void Main()

{

nowy wątek(nowy wątekStart(ThreadJob)).Start();

Wątek.Sen(1000);

Console.WriteLine("Blokowanie drugiej blokady");

zamek (drugi zamek)

{

Console.WriteLine("Druga blokada zablokowana");

Console.WriteLine("Pierwsza blokadaLock");

zamek (pierwszy zamek)

{

Console.WriteLine("Zablokowana pierwsza blokada");

}

Console.WriteLine("Zwolniono pierwszą blokadę");

}

Console.WriteLine("Zwolniono drugą blokadę");

Konsola.Odczyt();

}

}

}

Wyjście:

Blokowanie drugiegoZamka

Zablokowany drugiZamek

Blokowanie jako pierwszeZablokuj

Zablokowane jako pierwszeZablokuj

Wydany jako pierwszyLock

Zwolniony SecondLock

Umiejętności tworzenia oprogramowania na żądanie

Pule wątków

Pule wątków ułatwiają zarządzanie wieloma wątkami wykonywania w środowisku wielowątkowym w języku C#. Zapewniają one dostęp wszystkich wątków do kontrolowanych zasobów bez powodowania zakleszczeń.

Menedżer puli wątków opiekuje się pulą wątków, gdzie jest odpowiedzialny za tworzenie, niszczenie i planowanie wątków.

Oto przykład puli wątków przy użyciu TPL (Task Parallel Library):

przy użyciu Systemu;

przy użyciu System.Threading.Tasks;

Program klasowy

{

static void Main()

{

Zadanie<łańcuch> zadanie = Zadanie.Fabryka.StartNowy<ciąg>

(() => DownloadString("http://www.example.com/"));

ciąg wynik = zadanie.Wynik;

Console.WriteLine(wynik);

Konsola.Odczyt();

}

ciąg statyczny DownloadString(string uri)

{

przy użyciu (var wc = new System.Net.WebClient())

return wc.DownloadString(uri);

}

Wyjście:

Wynik zależy od zawartości dostępnej na stronie internetowej. Ten program zapewni pobieranie treści ze strony internetowej z określonego adresu URL. Następnie je wydrukuje.

Programowanie asynchroniczne z biblioteką zadań równoległych (TPL)

Biblioteka zadań równoległych (TPL) to potężne narzędzie do obsługi APIS i typów publicznych. Obsługuje System.Threading i System.Threading.Tasks .

.NET Framework 4 oferuje interfejsy API na poziomie języka i platformy dla programistów, którzy chcą pisać kod równoległy. Z pomocą TPL programowanie asynchroniczne umożliwia uruchamianie programów bez blokowania głównego wątku.

Oto przykład programowania asynchronicznego z TPL:

Zadanie<string> task = Task.Factory.StartNew<string>(() => {

zwróć „wynik”;

});

ciąg wynik = zadanie.Wynik;

Zadanie asynchroniczne MojaMetoda() {

ciąg wynik = czekaj na zadanie;

}

Sprawdź naszebezpłatne kursy technologiczne, aby uzyskać przewagę nad konkurencją.

Najlepsze praktyki dotyczące wielowątkowości w języku C#

Wielowątkowość może oszczędzić czas pod względem wydajności i wielozadaniowości. Aby dowiedzieć się więcej o tym, jak działa wielowątkowość, możesz wybrać tytuł magistra informatyki z LJMU .

Oto kilka najlepszych praktyk, które pomogą użytkownikom zaoszczędzić czas i osiągnąć najwyższą wydajność.

• Korzystaj z kolekcji bezpiecznych wątkowo: współbieżne kolekcje .NET Framework zapewniają bezpieczną wielowątkowo wersję każdej kolekcji, co ułatwia wydajną pracę wielowątkowości.Te kolekcje obejmują listy i zapytania oraz słowniki.
• Implementacja synchronizacji wątków: Użytkownicy mogą szybko wdrażać blokady, monitory i semafory ze względu na naturę narzędzi wątków.
• Używaj puli wątków: wielowątkowość może być łatwiejsza i bardziej wydajna dla systemów dzięki ogromnej większości puli wątków wykonywanej przez użytkowników.Jednocześnie użytkownicy mogą go używać do automatycznego tworzenia wątków.
• Używaj pamięci lokalnej dla wątków: podczas ćwiczenia wielowątkowości zapewnij dostęp do określonego zasobu, optymalizując pamięć lokalną dla wątków i oferując dostęp do wielu wątków.
• Unikaj udostępniania zmiennych stanów: wspólne zmienne stany doprowadzą tylko do błędów i warunków wyścigu, co może być trudne.Upewnij się, że za wszelką cenę unikasz stanów mutowalnych.
• Użyj modelu asynchronicznego: metody asynchroniczne pomagają w implementacji wielu zadań równolegle bez uruchamiania ich od nowa lub pozostawiania ich w kolejce.
• Unikaj zakleszczeń: podczas wykonywania programów z wykorzystaniem wielowątkowości można spodziewać się zakleszczeń.Pisząc program, staraj się uruchamiać wątek tylko po drugim, unikając zakleszczeń.
• Używaj tokenów anulowania: tokeny anulowania umożliwiają bezproblemowe kończenie wątków i unikanie zakleszczenia.

Zapoznaj się z naszymi popularnymi kursami inżynierii oprogramowania

Wniosek

Wielowątkowość w języku C# pozostaje podstawową koncepcją ze względu na jej wysokowydajny model w działaniu. Zapewnia programistom elastyczny sposób dzielenia obciążenia programu na wiele zadań wykonywanych równolegle i niezależnie.

Chociaż wielowątkowość może być bardzo korzystna, może prowadzić do potencjalnych przeszkód, jeśli nie zostanie starannie wdrożona.

Przy globalnym budżecie przeznaczonym na oprogramowanie dla przedsiębiorstw przekraczającym 856 miliardów dolarów w latach 2009-2023, rozwój oprogramowania obiecuje programistom świetlaną karierę.

Zgłoś się na kurs Full Stack Software Development Bootcamp od upGrad już teraz! Pełny kurs programowania może być odskocznią dla programistów, którzy chcą uwolnić swój potencjał w informatyce.