Une étude préliminaire sur le mécanisme multi-threading de C# (4)

exPRession représente l'objet que vous souhaitez suivre, généralement une référence d'objet. Généralement, si vous souhaitez protéger une instance d'une classe, vous pouvez l'utiliser ; si vous souhaitez protéger une variable statique (comme un segment de code mutuellement exclusif à l'intérieur d'une méthode statique), utilisez généralement le nom de la classe. Le Statement_block est le code de la section mutuellement exclusive. Ce code ne peut être exécuté que par un seul thread à la fois.

Ce qui suit est un exemple typique d'utilisation du mot-clé lock. J'expliquerai l'utilisation et le but du mot-clé lock dans les commentaires :

//lock.cs
 using System; = new Random();
compte interne (int initial)

{

balance = initial; }

interne int Retrait (int montant)
{
if (solde < 0)
 {
//Si le solde est inférieur à 0, lancez une exception
lancez une nouvelle exception ("Solde négatif"

);  }

//Le code suivant garantit qu'avant que le thread actuel ait terminé de modifier la valeur de balance
//Aucun autre thread n'exécutera ceci code pour modifier le solde Valeur
//Par conséquent, la valeur du solde ne peut pas être inférieure à 0
lock (ce)
{
 Console.WriteLine("Current Thread:" Thread.CurrentThread.Name);
//S'il n'y a pas de protection du mot clé de verrouillage, il peut être exécuté après le if Après avoir jugé la condition
//Un autre thread a exécuté balance=balance-amount et a modifié la valeur de balance
/ /Et cette modification a Ce fil est invisible, donc la condition if peut ne plus être valable à ce moment
//Cependant, ce fil continue d'exécuter balance=balance-amount, donc le solde peut être inférieur à 0
si (solde >= montant)
{
Thread .Sleep(5) ;     Balance = Solde -montant;
     Montant du retour
> }
}
}
vide interne DoTransactions()  for (int i = 0; i < 100; i )
Retrait(r.Next(-50, 100));
}
}

Test de classe interne
 {
static internal Thread[] threads = new Thread[10];
public static void Main()
{
 Account acc = nouveau compte (0);
pour (int i = 0; i < 10; i )
{
 Thread t = nouveau Thread(new ThreadStart(acc.DoTransactions));
threads [i] = t; >for (int i = 0; i < 10; i )
 threads[i].Name=i.ToString(); for (int i = 0; i < 10; i )
threads[i ].Start(); ();
}

}

Lorsque plusieurs threads partagent un objet, des problèmes similaires au code public se produiront. Pour ce type de problème, le mot-clé lock doit être utilisé. ne pas être utilisé. Ici, vous devez utiliser une classe Monitor dans System.Threading. Nous pouvons l'appeler un moniteur qui permet aux threads de partager des ressources.

La classe Monitor peut verrouiller un objet. Un thread ne peut opérer sur l'objet que s'il obtient le verrou. Le mécanisme de verrouillage d'objet garantit qu'un seul thread peut accéder à cet objet à la fois dans des situations susceptibles de provoquer le chaos. Monitor doit être associé à un objet spécifique, mais comme il s'agit d'une classe statique, il ne peut pas être utilisé pour définir des objets et toutes ses méthodes sont statiques et ne peuvent pas être référencées à l'aide d'objets. Le code suivant illustre l'utilisation de Monitor pour verrouiller un objet :

......
Queue oQueue=new Queue(
..... .
Monitor.Enter(oQueue);
......//Maintenant, l'objet oQueue ne peut être manipulé que par le thread actuel
Monitor.Exit(oQueue); // Libérez le verrouillage

Comme indiqué ci-dessus, lorsqu'un thread appelle la méthode Monitor.Enter() pour verrouiller un objet, l'objet lui appartient. Si d'autres threads souhaitent accéder à cet objet, ils ne peuvent qu'attendre qu'il l'utilise. Méthode Monitor.Exit(). Libérez le verrou. Afin de garantir que le thread finira par libérer le verrou, vous pouvez écrire la méthode Monitor.Exit() dans le bloc de code final de la structure try-catch-finally. Pour tout objet verrouillé par le moniteur, certaines informations qui lui sont liées sont stockées dans la mémoire. L'une est la référence du thread détenant actuellement le verrou, et l'autre est une file d'attente de préparation, qui stocke les objets prêts à acquérir le verrou. . Le troisième thread est une file d'attente, qui contient une référence à la file d'attente qui attend actuellement que l'état de l'objet change. Lorsque le thread propriétaire du verrou d'objet est prêt à libérer le verrou, il utilise la méthode Monitor.Pulse() pour avertir le premier thread de la file d'attente, afin que le thread soit transféré vers la file d'attente de préparation lorsque le verrou d'objet est libéré. , dans la file d'attente de préparation Le thread peut immédiatement acquérir le verrou d'objet.

Ce qui suit est un exemple montrant comment utiliser le mot-clé lock et la classe Monitor pour réaliser la synchronisation et la communication des threads. Il s'agit également d'un problème typique de producteur et de consommateur. Dans cette routine, le fil producteur et le fil consommateur alternent. Le producteur écrit un numéro, et le consommateur le lit et l'affiche immédiatement. Je présenterai l'essence du programme dans les commentaires. L'espace de noms système utilisé est le suivant :

using System
using System.Threading

Ce qui précède est le contenu du mécanisme multi-threading de C# (4), plus Pour le contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !