Multi-threading gebruiken met taken in C #

De computerprogrammeerterm 'thread' staat voor 'thread of execution', waarbij een processor een gespecificeerd pad door uw code volgt. Het concept om meer dan één thread tegelijk te volgen, introduceert het onderwerp multi-tasking en multi-threading.

Een applicatie bevat een of meer processen. Zie een proces als een programma dat op uw computer wordt uitgevoerd. Nu heeft elk proces een of meer threads. Een game-applicatie kan een thread hebben om bronnen van schijf te laden, een andere om AI te doen en een andere om de game als een server uit te voeren.

In .NET / Windows wijst het besturingssysteem processortijd toe aan een thread. Elke thread houdt uitzonderingshandlers bij en de prioriteit waarop deze wordt uitgevoerd, en er is ergens een threadcontext opgeslagen totdat deze wordt uitgevoerd. Thread context is de informatie die de thread moet hervatten.

Multi-Tasking met threads

Threads nemen een beetje geheugen in beslag en het maken ervan kost wat tijd, dus meestal wilt u er niet veel gebruiken. Vergeet niet dat ze strijden om processortijd. Als uw computer meerdere CPU's heeft, kan Windows of .NET elke thread op een andere CPU uitvoeren, maar als meerdere threads op dezelfde CPU worden uitgevoerd, kan er slechts één tegelijk actief zijn en het schakelen van threads kost tijd.

De CPU voert een thread uit voor een paar miljoen instructies en schakelt dan over naar een andere thread. Alle CPU-registers, het huidige programma-uitvoeringspunt en de stapel moeten ergens worden opgeslagen voor de eerste thread en vervolgens worden hersteld van ergens anders voor de volgende thread.

Een draad maken

In de naamruimte Systeem. Threading, u vindt het draadtype. De constructor-thread (ThreadStart) maakt een instantie van een thread. In recente C # -code is het echter waarschijnlijker dat deze een lambda-expressie doorgeeft die de methode met parameters aanroept.

Als je niet zeker bent over lambda-expressies, is het misschien de moeite waard om LINQ te bekijken.

Hier is een voorbeeld van een thread die is gemaakt en gestart:

het gebruik van systeem;

met behulp van System.Threading;
naamruimte ex1

klassenprogramma

public static void Write1 ()

Console.Write ('1');
Draad.Slapen (500);

statische void Main (string [] args)

var task = new Thread (Write1);
task.Start ();
voor (var i = 0; i < 10; i++)

Console.Write ('0');
Console.Write (task.IsAlive? 'A': 'D');
Draad.Slapen (150);

Console.ReadKey ();

Het enige dat dit doet, is "1" naar de console schrijven. De hoofdthread schrijft 10 keer een "0" naar de console, elke keer gevolgd door een "A" of "D" afhankelijk van of de andere thread nog levend of dood is.

De andere thread wordt slechts één keer uitgevoerd en schrijft een "1." Na de vertraging van een halve seconde in de thread Write1 () wordt de thread beëindigd en retourneert de Task.IsAlive in de hoofdlus nu "D."

Discussiepool en taak Parallelle bibliotheek

Gebruik in plaats van uw eigen thread te maken, tenzij u dit echt moet doen, een threadpool. Vanaf .NET 4.0 hebben we toegang tot de Task Parallel Library (TPL). Net als in het vorige voorbeeld hebben we opnieuw een beetje LINQ nodig, en ja, het zijn allemaal lambda-expressies.

Taken maakt gebruik van de thread pool achter de schermen, maar gebruik de threads beter afhankelijk van het gebruikte nummer.

Het hoofdobject in de TPL is een taak. Dit is een klasse die een asynchrone bewerking vertegenwoordigt. De meest gebruikelijke manier om dingen te starten is met de Task.Factory.StartNieuw zoals in: