C# - Multithreading

Een draad wordt gedefinieerd als het uitvoeringspad van een programma. Elke thread definieert een unieke stroom van controle. Als uw toepassing ingewikkelde en tijdrovende bewerkingen met zich meebrengt, is het vaak handig om verschillende uitvoeringspaden of threads in te stellen, waarbij elke thread een bepaalde taak uitvoert.

Discussies zijn lichtgewicht processen . Een veelvoorkomend voorbeeld van het gebruik van thread is de implementatie van gelijktijdige programmering door moderne besturingssystemen. Het gebruik van threads bespaart verspilling van CPU-cyclus en verhoogt de efficiëntie van een applicatie.

Tot nu toe hebben we de programma's geschreven waarin een enkele thread wordt uitgevoerd als een enkel proces dat de actieve instantie van de toepassing is. Op deze manier kan de toepassing echter één taak tegelijk uitvoeren. Om het meer dan één taak tegelijk te laten uitvoeren, kan het worden opgedeeld in kleinere threads.

Levenscyclus van threads

De levenscyclus van een thread begint wanneer een object van de klasse System.Threading.Thread wordt gemaakt en eindigt wanneer de thread wordt beëindigd of de uitvoering voltooit.

Hieronder volgen de verschillende toestanden in de levenscyclus van een thread −

• De niet-gestarte staat − Het is de situatie waarin de instantie van de thread wordt gemaakt maar de Start-methode niet wordt aangeroepen.

• De gereedstatus − Het is de situatie waarin de thread klaar is om te draaien en de CPU-cyclus wacht.

• De niet-uitvoerbare staat − Een thread is niet uitvoerbaar, wanneer

  • Slaapmethode is aangeroepen
  • Wachtmethode is aangeroepen
  • Geblokkeerd door I/O-bewerkingen

• De Dode Staat − Het is de situatie waarin de thread de uitvoering voltooit of wordt afgebroken.

De rode draad

In C# is de System.Threading.Thread class wordt gebruikt voor het werken met threads. Hiermee kunt u afzonderlijke threads maken en openen in een toepassing met meerdere threads. De eerste thread die in een proces moet worden uitgevoerd, wordt de main . genoemd draad.

Wanneer een C#-programma wordt uitgevoerd, wordt automatisch de hoofdthread gemaakt. De threads die zijn gemaakt met de Thread class worden de onderliggende threads van de hoofdthread genoemd. U kunt een thread openen met de CurrentThread eigenschap van de Thread-klasse.

Het volgende programma demonstreert de uitvoering van de hoofdthread −

using System;
using System.Threading;

namespace MultithreadingApplication {
   class MainThreadProgram {
      static void Main(string[] args) {
         Thread th = Thread.CurrentThread;
         th.Name = "MainThread";
         
         Console.WriteLine("This is {0}", th.Name);
         Console.ReadKey();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

This is MainThread

Eigenschappen en methoden van de Thread-klasse

De volgende tabel toont enkele meest gebruikte eigenschappen van de Thread klasse −

De volgende tabel toont enkele van de meest gebruikte methoden van de Thread klasse −

Draden maken

Threads worden gemaakt door de klasse Thread uit te breiden. De uitgebreide Thread-klasse roept dan de Start() . aan methode om de uitvoering van de onderliggende thread te starten.

Het volgende programma demonstreert het concept −

using System;
using System.Threading;

namespace MultithreadingApplication {
   class ThreadCreationProgram {
      public static void CallToChildThread() {
         Console.WriteLine("Child thread starts");
      }
      static void Main(string[] args) {
         ThreadStart childref = new ThreadStart(CallToChildThread);
         Console.WriteLine("In Main: Creating the Child thread");
         Thread childThread = new Thread(childref);
         childThread.Start();
         Console.ReadKey();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

In Main: Creating the Child thread
Child thread starts

Threads beheren

De klasse Thread biedt verschillende methoden voor het beheren van threads.

Het volgende voorbeeld demonstreert het gebruik van de sleep() methode om een ​​thread voor een bepaalde tijd te laten pauzeren.

using System;
using System.Threading;

namespace MultithreadingApplication {
   class ThreadCreationProgram {
      public static void CallToChildThread() {
         Console.WriteLine("Child thread starts");
         
         // the thread is paused for 5000 milliseconds
         int sleepfor = 5000; 
         
         Console.WriteLine("Child Thread Paused for {0} seconds", sleepfor / 1000);
         Thread.Sleep(sleepfor);
         Console.WriteLine("Child thread resumes");
      }
      
      static void Main(string[] args) {
         ThreadStart childref = new ThreadStart(CallToChildThread);
         Console.WriteLine("In Main: Creating the Child thread");
         
         Thread childThread = new Thread(childref);
         childThread.Start();
         Console.ReadKey();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

In Main: Creating the Child thread
Child thread starts
Child Thread Paused for 5 seconds
Child thread resumes

Draden vernietigen

De Afbreken() methode wordt gebruikt voor het vernietigen van threads.

De runtime breekt de thread af door een ThreadAbortException . Deze uitzondering kan niet worden opgevangen, de controle wordt verzonden naar de eindelijk eventueel blokkeren.

Het volgende programma illustreert dit −

using System;
using System.Threading;

namespace MultithreadingApplication {
   class ThreadCreationProgram {
      public static void CallToChildThread() {
         try {
            Console.WriteLine("Child thread starts");
            
            // do some work, like counting to 10
            for (int counter = 0; counter <= 10; counter++) {
               Thread.Sleep(500);
               Console.WriteLine(counter);
            }
            
            Console.WriteLine("Child Thread Completed");
         } catch (ThreadAbortException e) {
            Console.WriteLine("Thread Abort Exception");
         } finally {
            Console.WriteLine("Couldn't catch the Thread Exception");
         }
      }
      static void Main(string[] args) {
         ThreadStart childref = new ThreadStart(CallToChildThread);
         Console.WriteLine("In Main: Creating the Child thread");
         
         Thread childThread = new Thread(childref);
         childThread.Start();
         
         //stop the main thread for some time
         Thread.Sleep(2000);
         
         //now abort the child
         Console.WriteLine("In Main: Aborting the Child thread");
         
         childThread.Abort();
         Console.ReadKey();
      }
   }
}

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, levert dit het volgende resultaat op −

In Main: Creating the Child thread
Child thread starts
0
1
2
In Main: Aborting the Child thread
Thread Abort Exception
Couldn't catch the Thread Exception