Einführung in Multithreading in C #
Lassen Sie uns zunächst verstehen, was ein Thread ist, um Multithreading in c # zu verstehen.
- Ein Thread ist ein leichter Prozess.
- Es ist ein Ausführungspfad eines Programms.
- Es ist die kleinste Verarbeitungseinheit in einem Betriebssystem.
- Ein Prozess kann also mehrere Threads haben.
Multithreading ist also ein Prozess, der mehrere Threads enthält, wobei jeder Thread eine andere Aktivität ausführt. Dies spart Zeit, da mehrere Aufgaben gleichzeitig von verschiedenen Threads ausgeführt werden. Es erhöht die CPU-Auslastung und steigert die Effizienz einer Anwendung. Dies funktioniert nach dem Time-Sharing-Konzept.
Syntax mit Erklärung
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();
Um einen Thread zu erstellen, müssen wir ein Objekt der Thread-Klasse erstellen. Der Thread-Klassenkonstruktor nimmt Bezug auf ThreadStart. ThreadStart ist ein Delegat, der eine Methode darstellt, die ausgeführt werden muss, wenn der Thread mit der Ausführung beginnt.
Der Thread beginnt mit der Ausführung, wenn die Methode Start () aufgerufen wird.
Wir können einen Thread erstellen, ohne den ThreadStart-Delegaten zu verwenden, wie in der folgenden Syntax gezeigt:
Thread thread_name = new Thread(method_to_be_executed);
thread_name.Start();
Erstellen mehrerer Threads in C #
Um Threads zu erstellen, müssen Sie den Namespace system.Threading importieren. Wir können Threads mit der Thread-Klasse erstellen und initialisieren.
Beispiel mit Thread-Klasse
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();
)
)
Ausgabe:
Beispiel mit ThreadStart-Delegat
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();
)
)
Ausgabe:
In C # enthält ein Programm immer einen Thread, dh einen Haupt-Thread. Wenn wir andere Threads erstellen, wird dies zu einem Multithreading-Programm. In C # Multithreading gibt es zwei Arten von Threads:
- Vordergrund-Thread : Dieser Thread wird solange ausgeführt, bis er seine Arbeit beendet hat, auch wenn der Haupt-Thread beendet wird.
- Hintergrundthread : Wenn der Hauptthread beendet wird, stoppt auch der Hintergrundthread die Ausführung und endet mit dem Hauptthread.
Methoden mit Beispielen
Lassen Sie uns einige häufig verwendete Methoden der Thread-Klasse mit Beispielen sehen.
- Sleep (): Wird verwendet, um die Ausführung des aktuellen Threads für einen bestimmten Zeitraum anzuhalten, damit andere Threads mit der Ausführung beginnen.
Beispiel:
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();
)
)
Ausgabe:
Die Ausgabe zeigt, dass beide Threads parallel ausgeführt werden.
- Abort (): Wird verwendet, um den Thread zu beenden oder um die Ausführung des Threads dauerhaft zu stoppen.
Beispiel
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());
)
)
)
Ausgabe:
- Join (): Lässt alle aufrufenden Threads warten, bis der aktuelle Thread seine Ausführung abgeschlossen und beendet hat.
Beispiel:
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();
)
)
Ausgabe:
Vorteile von Multithreading in C #
- Hilft bei der Verwaltung einer ansprechenden Benutzeroberfläche: Manchmal haben wir eine zeitaufwändige Methode in unserer Anwendung. In diesem Fall übernimmt ein anderer Thread die Verantwortung für die Ausführung dieser Methode, wenn wir unsere Anwendung multithreadingfähig machen, während sich der Hauptthread auf die Reaktionsfähigkeit der Anwendung konzentrieren kann. Auf diese Weise wird unsere Anwendung nicht eingefroren, wenn dem Benutzer rechtzeitig eine angemessene Antwort gegeben wird.
- Steigert die Leistung der Anwendung: Wenn so viele Threads vorhanden sind, wie Prozessorkerne vorhanden sind, wird jeder Thread unabhängig ausgeführt und die Anzahl der Berechnungen pro Sekunde erhöht.
- Threads minimieren die Verwendung von Systemressourcen, da sie denselben Adressraum verwenden.
- Es macht Code gleichzeitig schneller und einfacher.
Fazit - Multithreading in C #
Die Thread-Klasse bietet viele wichtige Eigenschaften wie Priorität, Name, Ist-lebendig und Hintergrund, die wir in unserer Multithreading-Anwendung verwenden können. Die Thread-Synchronisierung ist eine Technik, mit der ein Thread für eine bestimmte Zeit auf eine Ressource zugreifen kann, ohne andere Threads zu unterbrechen, bis er seine Aufgabe erledigt hat.
Empfohlene Artikel
Dies war eine Anleitung zum Multithreading in C #. Hier diskutieren wir auch deren Einführung, Syntax, Erstellung und Beispiele für Multithreading in c #. Weitere Informationen finden Sie auch in den folgenden Artikeln.
- Objekte in C #
- Destruktor in C #
- Destruktor in C #
- Vererbung in C #
- Destruktor in PHP | Beispiele