Fabrication industrielle
Internet des objets industriel | Matériaux industriels | Entretien et réparation d'équipement | Programmation industrielle |
home  MfgRobots >> Fabrication industrielle >  >> Industrial programming >> Langue C

C# - Multithreading

Un fil est défini comme le chemin d'exécution d'un programme. Chaque thread définit un flux de contrôle unique. Si votre application implique des opérations compliquées et chronophages, il est souvent utile de définir différents chemins d'exécution ou threads, chaque thread effectuant une tâche particulière.

Les threads sont des processus légers . Un exemple courant d'utilisation de thread est la mise en œuvre de la programmation concurrente par les systèmes d'exploitation modernes. L'utilisation de threads évite le gaspillage du cycle CPU et augmente l'efficacité d'une application.

Jusqu'à présent, nous avons écrit les programmes où un seul thread s'exécute comme un seul processus qui est l'instance en cours d'exécution de l'application. Cependant, de cette façon, l'application peut effectuer une tâche à la fois. Pour lui faire exécuter plus d'une tâche à la fois, il pourrait être divisé en plus petits threads.

Cycle de vie du fil

Le cycle de vie d'un thread commence lorsqu'un objet de la classe System.Threading.Thread est créé et se termine lorsque le thread est terminé ou termine son exécution.

Voici les différents états du cycle de vie d'un thread −

Le fil principal

En C#, le System.Threading.Thread La classe est utilisée pour travailler avec les threads. Il permet de créer et d'accéder à des threads individuels dans une application multithread. Le premier thread à exécuter dans un processus est appelé main fil.

Lorsqu'un programme C# démarre son exécution, le thread principal est automatiquement créé. Les discussions créées à l'aide de Thread sont appelés les threads enfants du thread principal. Vous pouvez accéder à un fil à l'aide de CurrentThread propriété de la classe Thread.

Le programme suivant illustre l'exécution du thread principal −

Démo en direct
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();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −

This is MainThread

Propriétés et méthodes de la classe Thread

Le tableau suivant montre quelques propriétés les plus couramment utilisées du fil classe −

ContexteActuel

Obtient le contexte actuel dans lequel le thread s'exécute.

Culture actuelle

Obtient ou définit la culture du thread actuel.

Principe actuel

Obtient ou définit le principal actuel du thread (pour la sécurité basée sur les rôles).

Thread actuel

Obtient le thread en cours d'exécution.

Culture UI actuelle

Obtient ou définit la culture actuelle utilisée par le gestionnaire de ressources pour rechercher des ressources spécifiques à la culture au moment de l'exécution.

Contexte d'exécution

Obtient un objet ExecutionContext qui contient des informations sur les différents contextes du thread actuel.

Est vivant

Obtient une valeur indiquant l'état d'exécution du thread actuel.

IsBackground

Obtient ou définit une valeur indiquant si un thread est ou non un thread d'arrière-plan.

EstThreadPoolThread

Obtient une valeur indiquant si un thread appartient ou non au pool de threads gérés.

ID de thread géré

Obtient un identifiant unique pour le thread géré actuel.

Nom

Obtient ou définit le nom du thread.

Priorité

Obtient ou définit une valeur indiquant la priorité de planification d'un thread.

État du fil

Obtient une valeur contenant les états du thread actuel.

Sr.No. Propriété et description
1
2
3
4
5
6
7
8
9
10
11
12
13

Le tableau suivant présente certaines des méthodes les plus couramment utilisées du fil classe −

public void Abort()

Lève une ThreadAbortException dans le thread sur lequel elle est invoquée, pour commencer le processus de terminaison du thread. L'appel de cette méthode termine généralement le thread.

public statique LocalDataStoreSlot AllocateDataSlot()

Alloue un emplacement de données sans nom sur tous les threads. Pour de meilleures performances, utilisez plutôt les champs marqués avec l'attribut ThreadStaticAttribute.

public static LocalDataStoreSlot AllocateNamedDataSlot(string name)

Alloue un emplacement de données nommé sur tous les threads. Pour de meilleures performances, utilisez plutôt les champs marqués avec l'attribut ThreadStaticAttribute.

vide statique public BeginCriticalRegion()

Avertit un hôte que l'exécution est sur le point d'entrer dans une région de code dans laquelle les effets d'un abandon de thread ou d'une exception non gérée pourraient compromettre d'autres tâches dans le domaine d'application.

vide statique public BeginThreadAffinity()

Avertit un hôte que le code managé est sur le point d'exécuter des instructions qui dépendent de l'identité du thread physique actuel du système d'exploitation.

vide statique public EndCriticalRegion()

Avertit un hôte que l'exécution est sur le point d'entrer dans une région de code dans laquelle les effets d'un abandon de thread ou d'une exception non gérée sont limités à la tâche en cours.

public static void EndThreadAffinity()

Avertit un hôte que le code managé a fini d'exécuter des instructions qui dépendent de l'identité du thread physique actuel du système d'exploitation.

public static void FreeNamedDataSlot(string name)

Élimine l'association entre un nom et un emplacement, pour tous les threads du processus. Pour de meilleures performances, utilisez plutôt les champs marqués avec l'attribut ThreadStaticAttribute.

Objet statique public GetData (emplacement LocalDataStoreSlot)

Récupère la valeur de l'emplacement spécifié sur le thread actuel, dans le domaine actuel du thread actuel. Pour de meilleures performances, utilisez plutôt les champs marqués avec l'attribut ThreadStaticAttribute.

AppDomain public statique GetDomain()

Renvoie le domaine actuel dans lequel le thread actuel s'exécute.

AppDomain public statique GetDomainID()

Renvoie un identifiant de domaine d'application unique

public statique LocalDataStoreSlot GetNamedDataSlot(nom de la chaîne)

Recherche un emplacement de données nommé. Pour de meilleures performances, utilisez plutôt les champs marqués avec l'attribut ThreadStaticAttribute.

interruption publique vide()

Interrompt un thread qui est dans l'état de thread WaitSleepJoin.

public void Join()

Bloque le thread appelant jusqu'à ce qu'un thread se termine, tout en continuant à effectuer le pompage COM et SendMessage standard. Cette méthode a différentes formes surchargées.

public static void MemoryBarrier()

Synchronise l'accès à la mémoire comme suit :le processeur exécutant le thread actuel ne peut pas réorganiser les instructions de telle sorte que les accès à la mémoire avant l'appel à MemoryBarrier s'exécutent après les accès à la mémoire qui suivent l'appel à MemoryBarrier.

public static void ResetAbort()

Annule un abandon demandé pour le thread en cours.

public static void SetData (emplacement LocalDataStoreSlot, données d'objet)

Définit les données dans l'emplacement spécifié sur le thread en cours d'exécution, pour le domaine actuel de ce thread. Pour de meilleures performances, utilisez plutôt les champs marqués avec l'attribut ThreadStaticAttribute.

public void Start()

Démarre un fil.

public static void Sleep(int millisecondsTimeout)

Met le fil en pause pendant un certain temps.

public static void SpinWait(int itérations)

Fait attendre un thread le nombre de fois défini par le paramètre d'itérations

octet statique public VolatileRead (adresse d'octet de référence)

public static double VolatileRead(ref double address)

public static int VolatileRead(ref int address)

objet statique public VolatileRead (adresse de l'objet réf)

Lit la valeur d'un champ. La valeur est la dernière écrite par n'importe quel processeur d'un ordinateur, quel que soit le nombre de processeurs ou l'état du cache du processeur. Cette méthode a différentes formes surchargées. Seuls certains sont donnés ci-dessus.

public static void VolatileWrite (adresse d'octet de référence, valeur d'octet)

public static void VolatileWrite(ref double adresse, double valeur)

public static void VolatileWrite(adresse ref int, valeur int)

public static void VolatileWrite(ref adresse d'objet, valeur d'objet)

Écrit immédiatement une valeur dans un champ, afin que la valeur soit visible par tous les processeurs de l'ordinateur. Cette méthode a différentes formes surchargées. Seuls certains sont donnés ci-dessus.

public static bool Rendement()

Force le thread appelant à céder l'exécution à un autre thread prêt à s'exécuter sur le processeur actuel. Le système d'exploitation sélectionne le thread auquel céder.

Sr.No. Méthode et description
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Créer des sujets

Les threads sont créés en étendant la classe Thread. La classe Thread étendue appelle alors Start() méthode pour commencer l'exécution du thread enfant.

Le programme suivant illustre le concept −

Démo en direct
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();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −

In Main: Creating the Child thread
Child thread starts

Gestion des fils

La classe Thread fournit diverses méthodes de gestion des threads.

L'exemple suivant illustre l'utilisation de sleep() méthode pour mettre un thread en pause pendant une période de temps spécifique.

Démo en direct
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();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −

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

Détruire les fils

Le Abandonner() méthode est utilisée pour détruire les threads.

Le runtime abandonne le thread en lançant une ThreadAbortException . Cette exception ne peut pas être interceptée, le contrôle est envoyé au finalement bloquer, le cas échéant.

Le programme suivant illustre cela −

Démo en direct
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();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant −

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 

Langue C

  1. Diamètre de filetage mineur vs majeur des fixations
  2. Filetage
  3. Thread Vs. ZigBee (pour les ingénieurs IoT)
  4. Multithreading C++
  5. Python - Programmation multithread
  6. Edge Computing obtient enfin un cadre
  7. L'éclairage arrière devient rapide
  8. Comprendre le fil numérique
  9. Qu'est-ce qu'un coupe-fil ?