Inleiding tot multithreading in C #
Laten we eerst begrijpen wat een thread is om multithreading in c # te begrijpen.
- Een draad is een lichtgewicht proces.
- Het is een uitvoeringspad van een programma.
- Het is de kleinste verwerkingseenheid in een besturingssysteem.
- Een proces kan dus meerdere threads hebben.
Multithreading is dus een proces dat meerdere threads bevat, waarbij elke thread een andere activiteit uitvoert. Het bespaart tijd omdat meerdere taken tegelijkertijd door verschillende threads worden uitgevoerd. Het verhoogt het CPU-gebruik en verhoogt de efficiëntie van een applicatie. Dit werkt volgens het concept voor het delen van tijd.
Syntaxis met uitleg
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();
Om een thread te maken, moeten we een object van de klasse Thread maken. De constructeur van de Thread-klasse verwijst naar ThreadStart. ThreadStart is een gemachtigde die een methode vertegenwoordigt die moet worden uitgevoerd wanneer de thread met de uitvoering begint.
De thread begint met uitvoeren wanneer de methode Start () wordt aangeroepen.
We kunnen een thread maken zonder ThreadStart-afgevaardigde te gebruiken, zoals in onderstaande syntaxis wordt getoond:
Thread thread_name = new Thread(method_to_be_executed);
thread_name.Start();
Meerdere threads maken in C #
Om threads te maken, moeten we de naamruimte system.Threading importeren. We kunnen threads maken en initialiseren met behulp van de klasse Thread.
Voorbeeld met Thread Class
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();
)
)
Output:
Voorbeeld met ThreadStart-gemachtigde
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();
)
)
Output:
In C # bevat een programma altijd één thread, namelijk de hoofdthread. Wanneer we andere threads maken, wordt het een multithreading-programma en in C # multithreading zijn er twee soorten threads:
- Voorgrondthread : deze thread wordt uitgevoerd totdat deze zijn werk heeft voltooid, zelfs als de hoofdthread wordt beëindigd.
- Achtergrondthread : Wanneer de hoofdthread wordt beëindigd, stopt de achtergrondthread ook met uitvoeren en wordt de thread met de hoofdthread beëindigd.
Methoden met voorbeelden
Laten we een paar veelgebruikte methoden van de klasse Thread bekijken met voorbeelden.
- Sleep (): wordt gebruikt om de uitvoering van de huidige thread gedurende een opgegeven periode te pauzeren, zodat andere threads met de uitvoering beginnen.
Voorbeeld:
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();
)
)
Output:
De uitvoer laat zien dat beide threads parallel worden uitgevoerd.
- Afbreken (): wordt gebruikt om de thread te beëindigen of we kunnen zeggen dat deze wordt gebruikt om de uitvoering van de thread permanent te stoppen.
Voorbeeld
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());
)
)
)
Output:
- Join (): wordt gebruikt om alle aanroepende threads te laten wachten tot de huidige thread is voltooid en wordt beëindigd.
Voorbeeld:
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();
)
)
Output:
Voordelen van multithreading in C #
- Helpt bij het onderhouden van een responsieve gebruikersinterface: soms hebben we een tijdrovende methode in onze applicatie. Als we in dat geval onze applicatie multithreaded maken, neemt de andere thread de verantwoordelijkheid voor de uitvoering van die methode, terwijl de hoofdthread zich kan concentreren op de responsiviteit van de applicatie. Het zal onze applicatie dus niet bevriezen door de gebruiker tijdig een correct antwoord te geven.
- Verbetert de prestaties van de applicatie: als we evenveel threads hebben als er processorcores zijn, wordt elke thread onafhankelijk uitgevoerd, waardoor het aantal berekeningen per seconde toeneemt.
- Threads minimaliseren het gebruik van systeembronnen omdat ze dezelfde adresruimte delen.
- Het maakt code zowel sneller als eenvoudiger tegelijkertijd.
Conclusie - Multithreading in C #
Thread-klasse biedt veel belangrijke eigenschappen zoals Prioriteit, Naam, IsAlive, achtergrond die we kunnen gebruiken in onze multithreading-applicatie. Thread Synchronization is een techniek waarmee een thread gedurende een bepaalde tijd toegang heeft tot een resource zonder de onderbreking van andere threads totdat deze zijn taak heeft voltooid.
Aanbevolen artikelen
Dit is een gids geweest voor de multithreading in C #. Hier bespreken we ook hun introductie, syntaxis, creatie en voorbeelden van multithreading in c #. U kunt ook de volgende artikelen bekijken voor meer informatie–
- Objecten in C #
- Destructor in C #
- Destructor in C #
- Overerving in C #
- Destructor in PHP | Voorbeelden