C# - Multithreading: Ein Anfängerleitfaden

Hallo da draußen, zukünftige C#-Entwickler! Heute machen wir uns auf eine aufregende Reise in die Welt des Multithreading. Keine Sorge, wenn das beängstigend klingt - ich werde dein freundlicher Guide sein, und wir gehen das Schritt für Schritt durch. Am Ende dieses Tutorials wirst du wie ein Profi threaden!

C# - Multithreading

Was ist Multithreading?

Bevor wir eintauchen, lassen Sie uns verstehen, was Multithreading ist. Stell dir vor, du kochst ein komplexes Gericht. Du würdest nicht nur eine Aufgabe nach der anderen erledigen, oder? Vielleicht kochst du Pasta auf einem Herd, während du Gemüse schneidest und ein Auge auf die Sauce hast. Das ist Multitasking, und in der Welt der Programmierung nennen wir es Multithreading.

Multithreading ermöglicht es einem Programm, mehrere Aufgaben gleichzeitig auszuführen. Es ist, als hätte man mehrere Köche in der Küche, jeder verantwortlich für einen anderen Teil des Essens.

Lebenszyklus eines Threads

Genau wie wir Menschen haben Threads einen Lebenszyklus. Lassen Sie uns das aufschlüsseln:

Geboren (New): Der Thread wird erstellt, aber noch nicht gestartet.
Bereit: Der Thread ist bereit zum Laufen und wartet auf CPU-Zeit.
Laufend: Der Thread führt seine Aufgabe aus.
Blockiert: Der Thread ist vorübergehend angehalten (vielleicht wartend auf eine Ressource).
Tot: Der Thread hat seine Aufgabe beendet und läuft nicht mehr.

Hier ist eine einfache Visualisierung:

New -> Ready -> Running -> Dead
^        |
|        v
<-- Blocked

Der Hauptthread

Wenn du ein C#-Programm startest, erstellt es automatisch einen Thread namens Main Thread. Es ist wie der Chefkoch in unserer Küchenanalogie. Lassen Sie es in Aktion sehen:

using System;
using System.Threading;

class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hauptthread: " + Thread.CurrentThread.ManagedThreadId);
}
}

Wenn du das ausführst, wirst du etwas wie sehen:

Hauptthread: 1

Dies zeigt, dass unser Programm im Hauptthread läuft, der immer die ID 1 hat.

Eigenschaften und Methoden der Thread-Klasse

Die Thread-Klasse in C# bringt eine Menge nützlicher Eigenschaften und Methoden mit. Lassen Sie uns einige der häufigsten anschauen:

Eigenschaft/Methode	Beschreibung
ManagedThreadId	Gibt die eindeutige Identifikation für den Thread zurück
IsAlive	Gibt an, ob dieser Thread gestartet wurde und nicht beendet wurde
Name	Gibt oder setzt den Namen des Threads
Priority	Gibt oder setzt die Planungspriorität des Threads
Start()	Startet den Thread
Sleep()	Setzt den Thread für eine bestimmte Zeit aus
Join()	Blockiert den aufrufenden Thread, bis dieser Thread beendet wird

Lassen Sie uns einige davon in Aktion sehen:

using System;
using System.Threading;

class Program
{
static void Main(string[] args)
{
Thread t = new Thread(DoWork);
t.Name = "Arbeitsthread";
Console.WriteLine("Thread starten...");
t.Start();
t.Join();
Console.WriteLine("Thread beendet");
}

static void DoWork()
{
Console.WriteLine($"Thread {Thread.CurrentThread.Name} arbeitet");
Thread.Sleep(1000);
Console.WriteLine($"Thread {Thread.CurrentThread.Name} hat die Arbeit beendet");
}
}

Dieses Programm erstellt einen neuen Thread, benennt ihn, startet ihn, wartet auf sein Ende und führt dann fort. Die Ausgabe wird sein:

Thread starten...
Thread Arbeitsthread arbeitet
Thread Arbeitsthread hat die Arbeit beendet
Thread beendet

Erstellen von Threads

Das Erstellen von Threads in C# ist so, als würde man neue Köche für unsere Küche einstellen. Hier ist, wie wir das tun:

using System;
using System.Threading;

class Program
{
static void Main(string[] args)
{
// Thread mit einer benannten Methode erstellen
Thread t1 = new Thread(DoWork);
t1.Start();

// Thread mit einer anonymen Methode erstellen
Thread t2 = new Thread(() =>
{
Console.WriteLine("Thread 2 arbeitet");
});
t2.Start();

// Thread mit Parametern erstellen
Thread t3 = new Thread(param =>
{
Console.WriteLine($"Thread 3 sagt: {param}");
});
t3.Start("Hallo aus Thread 3!");
}

static void DoWork()
{
Console.WriteLine("Thread 1 arbeitet");
}
}

Dieses Beispiel zeigt drei verschiedene Möglichkeiten, Threads zu erstellen. Führe es aus und sieh, was passiert!

Verwalten von Threads

Die Verwaltung von Threads ist entscheidend für ein effizientes Multithreading. Lassen Sie uns einige Möglichkeiten dazu anschauen:

using System;
using System.Threading;

class Program
{
static void Main(string[] args)
{
Thread t = new Thread(DoWork);
t.Start();

// Warte auf das Ende des Threads
t.Join();

// Setze die Thread-Priorität
t.Priority = ThreadPriority.Highest;

// Überprüfe, ob der Thread aktiv ist
Console.WriteLine($"Ist der Thread aktiv? {t.IsAlive}");

// Setze den Hauptthread für eine Weile aus
Thread.Sleep(1000);
}

static void DoWork()
{
for (int i = 0; i < 5; i++)
{
Console.WriteLine($"Arbeiten... {i}");
Thread.Sleep(500);
}
}
}

Dieses Beispiel zeigt, wie man auf das Ende eines Threads wartet, seine Priorität setzt, seinen Status überprüft und einen Thread einschläft.

Zerstören von Threads

In C# zerstören wir Threads nicht manuell. Threads terminieren automatisch, wenn sie ihre Arbeit beendet haben oder wenn die Anwendung beendet wird. Allerdings können wir einen Thread mit der Abort()-Methode anweisen, zu stoppen, although es wird generell nicht empfohlen, aufgrund möglicher Probleme bei der Ressourcenbereinigung.

Hier ist ein Beispiel für die Verwendung von Abort(), aber denken Sie daran, es ist besser, Threads so zu gestalten, dass sie natürlich beenden:

using System;
using System.Threading;

class Program
{
static void Main(string[] args)
{
Thread t = new Thread(DoWork);
t.Start();

Thread.Sleep(2000); // Lasse den Thread 2 Sekunden lang laufen

t.Abort(); // Beende den Thread
Console.WriteLine("Thread beendet");
}

static void DoWork()
{
while (true)
{
Console.WriteLine("Arbeiten...");
Thread.Sleep(500);
}
}
}

Dies wird den Thread etwa 2 Sekunden lang laufen lassen, bevor er abgebrochen wird.

Und da hast du es! Du hast gerade deinen ersten C#-Multithreading-Lektion abgeschlossen. Denke daran, wie das Kochen, erfordert das Beherrschen von Multithreading Übung. Also fürchte dich nicht, mit diesen Konzepten zu experimentieren. Frohes Coden und mögen deine Threads immer reibungslos laufen!

Credits: Image by storyset

Vorheriges Tutorial:

C# - Unsichere Codes