Horloge

En C #, la construction de verrouillage est souvent utilisée pour garantir qu'aucun processus ne peut entrer un morceau de code lorsqu'un autre processus est en cours d'exécution (I.e. Ressources demandées par plus d'un processus.) Le deuxième thread essayant d'accéder à un morceau de code dans lequel un processus est déjà maintenu jusqu'à ce que le processus en cours d'exécution dans le code termine son exécution. Ainsi, l'utilisation du verrou est une technique plus rapide et plus efficace pour gérer les processus dans la programmation multithreading. Cette prise est libérée une fois que le processus qui s'exécute actuellement dans la partie du code a terminé son exécution, permettant à d'autres processus de fonctionner dans le morceau de code. Par conséquent, nous avons décidé d'élaborer la construction «Lock» dans ce code C # pour nos programmeurs travaillant sur Ubuntu 20.04 Système. Nous avons commencé cet article avec une nouvelle création de fichiers dans le shell.

Exemple # 01: sans construction de verrouillage

Commençons par le premier exemple de cet article pour l'utilisation de verrouillage en C #. Donc, nous devons d'abord faire une structure de code C #. Sans la structure de code standard C #, notre code ne fonctionnera pas. Ainsi, vous devez le démarrer avec l'utilisation de la bibliothèque «système» spécifiée par le mot-clé «Utilisation» dans le code. Comme nous devons travailler sur les threads, nous devons spécifier l'espace de noms de filetage de la bibliothèque système via le mot-clé «Utilisation».

Les deux bibliothèques sont nécessaires pour la mise en œuvre de verrouillage et de threads dans nos exemples dans cet article. Après cela, nous avons initialisé une simple classe «test» dans le code C #. Vous pouvez également définir un espace de noms avant le cours, mais il n'est pas nécessaire ici. La classe «test» contient un total de 2 fonctions. L'un est une fonction définie par l'utilisateur nommé «Show ()» et l'autre est la fonction principale () de C # qui est également une fonction exécuteur dans les codes C #. Le processus d'exécution commence à partir de la méthode principale de ce programme. Nous utilisons la classe «Thread» de l'espace de noms «de threading» pour la création de deux nouveaux objets de thread T1 et T1 à l'aide d'un «nouveau» mot-clé.

Dans la création de thread, nous avons utilisé la fonction «Show» dans les arguments du «thread» pour en faire une fonction de thread. Comme nous avons créé 2 threads, cela signifie que la fonction Show () sera utilisée 2 fois dans le code comme thread 1 et thread 2 respectivement. Ceci est juste une création de threads et non son exécution. Pour exécuter le thread, nous devons utiliser la fonction «Démarrer» à partir de l'espace de noms de classe de filetage. Ainsi, l'objet «T1» du thread 1 a été utilisé pour appeler la fonction «Démarrer» pour exécuter la fonction de thread «Show». Après le premier thread, le deuxième thread T2 exécutera la méthode «Show» en utilisant la même fonction de démarrage. Maintenant, lorsqu'un thread a été démarré, la fonction Show () sera exécutée en utilisant sa boucle «For» pour jusqu'à 5 itérations. Jusqu'à l'exécution de la boucle, elle continuera d'exécuter sa «console.Instruction de fonction writeLine () ”pour afficher le numéro d'itération à l'aide de la variable d'itération« I ». Après chaque itération, le fil dormira de 3 secondes en utilisant la fonction «sommeil» de C # ici. La même chose sera répétée lorsqu'un deuxième fil commencera. Maintenant, comme nous utilisons des threads pour exécuter la fonction «Show», il n'est pas sûr qu'il l'exécutera d'une manière où . Thread 1 d'abord puis fil 2. Enregistrons notre code pour voir son résultat.

Nous avons besoin de commandes C # Compiler et Runtime Environment pour compiler et exécuter nos codes. Nous avons déjà installé les deux. Ainsi, nous avons utilisé la commande C # «MCS» utilisée comme compilateur C # pour compiler ce code nouvellement fabriqué. La compilation ne renvoie rien mais génère un nouveau fichier «exe» dans le même dossier actuel i.e. réussi.

Nous avons donc exécuté ce fichier «exe» pour le code C # avec la commande d'exécution «mono» de C #. Au fur et à mesure que les deux threads ont commencé dans la fonction principale (), ils continuent à exécuter la fonction show () l'un après l'autre sur chaque itération. Cela signifie qu'un thread prenait les ressources de l'autre fil tandis que le premier n'a même pas terminé son exécution pleinement. Cela peut également provoquer une impasse.

Exemple # 02: avec construction de verrouillage

Pour empêcher les threads de s'exécuter en même temps pendant que les ressources sont partagées ou demandées, nous devons utiliser la construction «Lock» dans le code C #. La construction de verrouillage assurera, ne permettra pas à aucun autre fil d'obtenir des ressources actuellement utilisées par le processus en cours d'exécution jusqu'à ce qu'il termine son exécution. Cela peut fonctionner sur la règle de priorité ou . premier arrivé premier servi. Pour utiliser la construction «Lock», nous devons créer un objet pour le verrouillage en utilisant la classe «Objet» de C #.

Cet objet doit être de type en lecture seule statique. Vous pouvez le nommer tout ce que vous souhaitez. La création d'un objet de verrouillage assure qu'un verrou est créé et non appliqué à certaines parties du code. Nous l'avons nommé «arrêt». Maintenant, nous devons créer une construction avec son mot-clé «verrouillage» et spécifier le nom de verrouillage dans ses arguments comme «arrêter» dans la fonction «show». Comme la fonction show () est notre thread, nous devons mettre son implémentation dans la construction «Lock» (i.e. le morceau de code auquel nous voulons restreindre l'accès.) Maintenant, notre code est prêt car le verrou a été appliqué au morceau de code dans la fonction de thread. Enregistrez ce code mis à jour et exécutez-le pour voir son résultat.

Nous avons compilé ce code mis à jour sur notre terminal Ubuntu et exécuté son fichier «exe» après cela. Cette fois, toute la fonction «Show» a été entièrement exécutée (i.e. La boucle «pour» est terminée.) En effet. Après cela, cela est également arrivé au fil 2. Par conséquent, notre sortie est lisse.

La sortie préfabriquée s'affichera sans aucune pause et dans une seconde sur votre écran. Cela ne vous permettra pas de voir comment une itération fonctionne les unes après les autres lorsqu'il n'y a pas de retard dans l'exécution lors de l'utilisation d'un verrouillage. Mise à jour la fonction «Show» dans le même code et ajoutons la fonction de sommeil en prenant 2 secondes de sommeil après l'exécution de la console.Instruction de fonction writeLine () tout en itérant. Enregistrez ce code avec Ctrl + S, fermez le fichier et ouvrez le shell.

Après avoir compilé le fichier de code, nous avons exécuté son fichier «exe» sur le shell. Le code commence à exécuter ses threads. Le premier fil «Show» a commencé pendant le sommeil pendant 2 secondes après chaque itération comme indiqué ci-dessous.

Une fois que le premier thread «Show» a terminé son exécution, le verrou a publié l'accès à la fonction Show et le thread 2 l'a acquis pour exécution.

Conclusion:

Cet article contient des détails sur la construction de verrouillage en C #. Nous avons discuté de notre premier exemple sans utiliser la construction «Lock» et obtenu une sortie avec l'exécution aléatoire et non ordonnée d'une fonction de thread. Nous avons également discuté des causes de cette exécution non ordonnée du fil. Après cela, nous avons discuté d'un exemple avec l'utilisation de la construction «verrouillage» et obtenu une sortie avec une manière aléatoire d'exécution de threads.