Multithreading in C#: Vorteile, Grundlagen und Best Practices

Was ist Multithread-Programmierung?

Multithreading ist ein grundlegendes Konzept in der Softwareentwicklung. In C# ist Multithread-Programmierung für Softwareentwickler, die mit dem .NET Framework arbeiten, unerlässlich. Entwickler nutzen Multithreading in C# häufig , da es ihnen ermöglicht, komplexe und reaktionsfähige Anwendungen effizient zu erstellen.

Dieser Blog bietet einen Überblick über C#-Multithreading und befasst sich gleichzeitig damit, wie Programmierer Threads einfach erstellen und verwalten können. Es umfasst auch die Vorteile der Verwendung von Multithreading und der verschiedenen in C# verfügbaren Threading-Modelle.

Vorteile und Vorteile der Multithread-Programmierung

Bei gleichzeitiger Ausführung verbessert Multithreading die Effektivität von Anwendungen. Zu den häufigsten Vorteilen des C#-Threads gehören die folgenden:

• Verbesserte Anwendungsleistung: Mithilfe von Multithreading werden Anwendungen schneller ausgeführt, da mehrere Aufgaben im selben Raum ausgeführt werden.Insgesamt verkürzt es die Ausführungszeit und macht Platz für mehrere Aufgaben.
• Erhöhter Durchsatz: Multitasking in C# erhöht den Durchsatz von Anwendungen.Wenn zwei verschiedene Threads gleichzeitig ausgeführt werden, können Zeit und Ressourcen gespart werden.
• Verbesserte Reaktionsfähigkeit: Mithilfe von Multithreading kann ein Benutzer auf das Frontend der Anwendung zugreifen, während das Programm im Hintergrund läuft.
• Erhöhte Ressourcennutzung: Multithreading ermöglicht Benutzern einen effizienteren Zugriff auf Systemressourcen.Threads können beispielsweise Ressourcen wie Dateien, Speicher und E/A-Geräte gemeinsam nutzen und so den Weg zur Effizienz ebnen.
• Leicht zugänglichere Programmierung: Multithreading ermöglicht eine einfachere Programmierung, da Benutzer Threads unabhängig schreiben können.Außerdem können Benutzer Anwendungen isoliert debuggen und testen.
• Optimierte Kommunikation: Die Thread-Synchronisierung ermöglicht eine bessere Prozess-zu-Prozess-Kommunikation.Es kann für eine besser zugängliche Kommunikation zwischen Threads verwendet werden.

Zum einen betrifft es einzelne Objekte, die synchronisiert werden können. Zweitens kann es mit der System.Threading- und Interlocked-Klasse verwendet werden.

Grundlegende Konzepte von Multithreading in C#

Multithreading ermöglicht es Benutzern, mithilfe mehrerer Prozessorkerne mehrere Aufgaben gleichzeitig zu erledigen. Hier sind die grundlegenden Konzepte, die beim Multithreading verwendet werden:

• Threads: Threads sind die Grundeinheiten im Multithreading, die bei der Ausführung eines Prozesses helfen.Dabei handelt es sich um Ausführungspfade innerhalb eines bestimmten Programms, die gleichzeitig mit anderen Threads ausgeführt werden können.

In C# gibt es zwei Arten von Threads, nämlich Vordergrund- und Hintergrund-Threads. Die durchschnittliche Thread-Klasse umfasst einen Namen, eine Priorität, isAlive, ThreadState, Start(), Suspend(), Resume() und Join().

• Thread-Pool: Ein Thread-Pool ist ein Thread, der bei der Ausführung von Aufgaben hilft.Dadurch kann das Betriebssystem vorhandene Threads wiederverwenden und das Risiko eines möglichen Overheads minimieren.
• Synchronisierung: Bei der Synchronisierung wird der Zugriff auf andere Threads für mehrere Vorgänge übersehen.Dies ist ein wesentlicher Prozess, um die Datenintegrität aufrechtzuerhalten und Overheads zu vermeiden.
• Deadlock: Ein Deadlock ist ein Fehler, der auftritt, wenn zwei Threads Ressourcen gemeinsam nutzen und versuchen, erfolglos fortzufahren.Dies kann zum Einfrieren des Systems oder sogar zu einer Wartezeit führen.
• Asynchrone Programmierung: Asynchrone Programmierung ermöglicht die Ausführung mehrerer Aufgaben im Hintergrund, während der Hauptthread ohne Unterbrechung ausgeführt werden kann.Es ebnet den Weg für mehrere reaktionsfähige Benutzeroberflächen und verbessert so die Anwendungsleistung.

Threads erstellen und ausführen

Mit diesen Beispielen kann das Erstellen und Ausführen einfacher sein. Nachfolgend finden Sie ein C#-Multithreading-Beispiel :

Verwenden des Systems;

Verwenden von System.Threading;

Klassenprogramm {

static void Main() {

int workerIndex = 0;

Thread workerThread = new Thread(new ThreadStart(Worker));

workerThread.Start();

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

Console.WriteLine(“Hauptthread: {0}”, mainIndex);

Thread.Sleep(200);

}

workerThread.Join();

}

static void Worker() {

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

Console.WriteLine(“Worker-Thread: {0}”, workerIndex * 2);

Thread.Sleep(200);

}

}

}

Ausgang:

Hauptthread: 1

Arbeitsthread: 2

Hauptthread: 2

Arbeitsthread: 4

Hauptthread: 3

Arbeitsthread: 6

Hauptthread: 4

Arbeitsthread: 8

Hauptthread: 5

Arbeitsthread: 10

Hauptthread: 6

Arbeitsthread: 12

Hauptthread: 7

Arbeitsthread: 14

Hauptthread: 8

Arbeitsthread: 16

Hauptthread: 9

Arbeitsthread: 18

Hauptthread: 10

Arbeitsthread: 20

Erläuterung: In dieser Ausgabe arbeiten beide Threads gleichzeitig daran, die Zahlen 1 bis 10 und 2 bis 20 auszugeben, wobei letztere gegenüber dem Schleifenindex verdoppelt werden.In diesem Beispiel wurde die C#-Thread-Sleep- Methode (Thread.Sleep) verwendet.

Auf die gleiche Weise werden wir uns ein weiteres C#-Thread-Beispiel ansehen, das den Vordergrund-Thread verwendet:

Verwenden des Systems;

Verwenden von System.Threading;

Klassenprogramm {

static void Main() {

Thread myThread = neuer Thread(Worker);

myThread.Start();

Console.WriteLine(“Hauptthread: Gestartet”);

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

Console.WriteLine(“Hauptthread: Anzahl {0}”, i);

Thread.Sleep(500);

}

Console.WriteLine(“Hauptthread: Beendet”);

}

static void Worker() {

für (in j = 1; j <= 5; j++) {

Console.WriteLine(“Worker Thread: Count {0}”, j * 3);

Thread.Sleep(750);

}

Console.WriteLine(“Worker-Thread: Beendet”);

}

}

Ausgang:

Hauptthread: Gestartet

Arbeiterthread: Zählung 3

Hauptthread: Zählung 1

Arbeiterthread: Zählung 6

Hauptthread: Zählung 2

Arbeiterthread: Zählung 9

Hauptthread: Zählung 3

Arbeiterthread: Zählung 12

Hauptthread: Zählung 4

Arbeiterthread: Anzahl 15

Hauptthread: Zählung 5

Arbeiterthread: Beendet

Hauptthread: Beendet

Erläuterung: Diese Ausgabe zeigt, wie die beiden Threads gleichzeitig arbeiten.Da der Haupt- und der Hintergrund-Thread parallel arbeiten, gibt der Haupt-Thread Zahlen von 1 bis 5 aus. Der Arbeits-Thread gibt Vielfache von 3 bis 15 aus.

Schauen Sie sich Softwareentwicklungskurse bei upGrad an, um sich weiterzubilden.

Lesen Sie unsere beliebten Artikel zum Thema Softwareentwicklung

Thread-Synchronisierung

Bei der Thread-Synchronisation handelt es sich um die kollektive Koordination mehrerer Threads in einem Programm. Es stellt sicher, dass das Programm in einer bestimmten Reihenfolge ausgeführt wird, wodurch Zugriff auf gemeinsam genutzte Ressourcen ermöglicht wird.

In C# erfolgt dies mithilfe von Synchronisierungsprimitiven wie dem Schlüsselwort lock, Synchronisierungsobjekten und der Interlocked-Klasse.

Nachfolgend finden Sie ein Beispiel für die C#-Thread- Synchronisierung:

Verwenden des Systems;

Verwenden von System.Threading;

Klasse TablePrinter

{

public void PrintTable()

{

sperren (dies)

{

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

{

Thread.Sleep(200);

Console.WriteLine(i*5);

}

}

}

}

Klassenprogramm

{

public static void Main(string[] args)

{

TablePrinter tp = new TablePrinter();

Thread t1 = neuer Thread(new ThreadStart(tp.PrintTable));

Thread t2 = neuer Thread(new ThreadStart(tp.PrintTable));

t1.Start();

t2.Start();

}

}

Ausgang:

15

20

25

30

35

40

45

50

55

60

Entdecken Sie unsere kostenlosen Kurse zur Softwareentwicklung

Deadlocks

Deadlocks beim Multithreading treten auf, wenn mindestens zwei oder mehr Threads von einer Reihe von Ressourcen abhängig sind. Wenn ein Thread die Route zur Hilfe überschneidet, während der andere versucht, dasselbe zu tun, kommt es zu einem Deadlock.

Wenn Thread A beispielsweise eine Sperre für Ressource 1 hat und auf den Zugriff auf Ressource 2 wartet, während Thread B auf Ressource 1 wartet, kann dies zu einem Deadlock führen.

Nachfolgend finden Sie ein Beispiel:

Verwenden des Systems;

Verwenden von System.Threading;

Namespace Deadlockincsharp

{

Beispiel für eine öffentliche Klasse

{

statisches schreibgeschütztes Objekt firstLock = new object();

statisches schreibgeschütztes Objekt secondLock = new object();

static void ThreadJob()

{

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

Sperre (firstLock)

{

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

Thread.Sleep(1500);

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

lock (secondLock)

{

Console.WriteLine(“\t\t\t\tLocked secondLock“);

}

Console.WriteLine(“\t\t\t\tReleased secondLock“);

}

Console.WriteLine(“\t\t\t\tReleased firstLock“);

}

static void Main()

{

neuer Thread(new ThreadStart(ThreadJob)).Start();

Thread.Sleep(1000);

Console.WriteLine(“SecondLock sperren”);

lock (secondLock)

{

Console.WriteLine(“SecondLock gesperrt”);

Console.WriteLine(“FirstLock sperren”);

Sperre (firstLock)

{

Console.WriteLine(“Locked firstLock”);

}

Console.WriteLine(“Released firstLock“);

}

Console.WriteLine(“SecondLock freigegeben”);

Console.Read();

}

}

}

Ausgang:

SecondLock sperren

SecondLock gesperrt

FirstLock sperren

Zuerst gesperrt

FirstLock veröffentlicht

SecondLock freigegeben

Gefragte Fähigkeiten in der Softwareentwicklung

Thread-Pools

Thread-Pools helfen bei der Verwaltung mehrerer Ausführungsthreads in einer Multithread-Umgebung in C#. Diese stellen sicher, dass alle Threads Zugriff auf kontrollierte Ressourcen haben, ohne dass es zu Deadlocks kommt.

Ein Thread-Pool-Manager kümmert sich um den Thread-Pool und ist für die Erstellung, Zerstörung und Planung von Threads verantwortlich.

Hier ist ein Beispiel für einen Thread-Pool mit TPL (Task Parallel Library):

Verwenden des Systems;

Verwenden von System.Threading.Tasks;

Klassenprogramm

{

static void Main()

{

Task<string> task = Task.Factory.StartNew<string>

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

string result = task.Result;

Console.WriteLine(result);

Console.Read();

}

statischer String DownloadString(string uri)

{

using (var wc = new System.Net.WebClient())

return wc.DownloadString(uri);

}

Ausgang:

Die Ausgabe hängt von den auf der Webseite verfügbaren Inhalten ab. Dieses Programm stellt sicher, dass Inhalte von der Webseite von der angegebenen URL heruntergeladen werden. Anschließend werden sie ausgedruckt.

Asynchrone Programmierung mit Task Parallel Library (TPL)

Die Task Parallel Library (TPL) ist ein leistungsstarkes Tool für den Umgang mit APIS und öffentlichen Typen. Es verarbeitet System.Threading und System.Threading.Tasks .

Das .NET Framework 4 bietet APIs auf Sprach- und Framework-Ebene für Entwickler, die parallelen Code schreiben möchten. Mit Hilfe von TPL ermöglicht die asynchrone Programmierung die Ausführung von Programmen, ohne den Hauptthread zu blockieren.

Hier ist ein Beispiel für asynchrone Programmierung mit TPL:

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

„Ergebnis“ zurückgeben;

});

string result = task.Result;

asynchrone Aufgabe MyMethod() {

string result = Aufgabe abwarten;

}

Schauen Sie sich unserekostenlosen Technologiekurse an , um sich von der Konkurrenz abzuheben.

Best Practices für Multithreading in C#

Multithreading kann im Hinblick auf Leistung und Multitasking eine Zeitersparnis bedeuten. Um mehr über die Funktionsweise von Multithreading zu erfahren, können Sie sich für einen Master of Science in Informatik an der LJMU entscheiden .

Hier sind einige Best Practices, die Benutzern helfen, Zeit zu sparen und die höchste Effizienz zu erzielen.

• Nutzen Sie threadsichere Sammlungen: Die gleichzeitigen Sammlungen von .NET Framework stellen eine threadsichere Version jeder Sammlung bereit, was die effiziente Arbeit von Multithreading erleichtert.Zu diesen Sammlungen gehören Listen und Abfragen sowie Wörterbücher.
• Thread-Synchronisierung implementieren: Benutzer können aufgrund der Art von Thread-Tools schnell Sperren, Monitore und Semaphoren implementieren.
• Verwenden Sie Thread-Pooling: Multithreading kann für Systeme einfacher und effizienter sein, da der Großteil des Thread-Poolings von Benutzern durchgeführt wird.Gleichzeitig können Benutzer damit automatisch Threads erstellen.
• Verwenden Sie Thread-lokalen Speicher: Stellen Sie beim Üben von Multithreading den Zugriff auf eine bestimmte Ressource sicher, indem Sie den Thread-lokalen Speicher optimieren und Zugriff auf mehrere Threads anbieten.
• Vermeiden Sie die gemeinsame Nutzung veränderlicher Zustände: Gemeinsam genutzte veränderliche Zustände führen nur zu Fehlern und Race Conditions, was schwierig sein kann.Vermeiden Sie unbedingt veränderliche Zustände.
• Asynchrones Modell verwenden: Asynchrone Methoden helfen Ihnen, mehrere Aufgaben parallel umzusetzen, ohne sie erneut zu starten oder in der Warteschlange zu belassen.
• Deadlocks vermeiden: Bei der Ausführung von Programmen mittels Multithreading ist mit Deadlocks zu rechnen.Versuchen Sie beim Schreiben eines Programms, einen Thread erst nach dem anderen auszuführen, um Deadlocks zu vermeiden.
• Abbruchtokens verwenden: Abbruchtokens ermöglichen das problemlose Beenden von Threads und vermeiden Deadlocks.

Entdecken Sie unsere beliebten Software-Engineering-Kurse

Abschluss

Multithreading in C# bleibt mit seinem hocheffizienten Modell ein wesentliches Konzept. Es bietet Programmierern eine flexible Möglichkeit, die Arbeitslast eines Programms in mehrere Aufgaben aufzuteilen, die gleichzeitig und unabhängig voneinander ausgeführt werden.

Obwohl Multithreading sehr vorteilhaft sein kann, kann es zu potenziellen Hindernissen führen, wenn es nicht sorgfältig umgesetzt wird.

Da das globale Budget für Unternehmenssoftware zwischen 2009 und 2023 856 Milliarden US-Dollar übersteigt , verspricht die Softwareentwicklung eine glänzende Karriere für Entwickler.

Bewerben Sie sich jetzt für das Full Stack Software Development Bootcamp von upGrad ! Ein Full-Stack-Entwicklungskurs kann das Sprungbrett für Entwickler sein, die ihr Potenzial in der Informatik entfalten möchten.