Verrouillage multiprocesseur python

Le package multiprocesseur de Python permet aux utilisateurs de créer de nouveaux processus et d'accéder à l'API Python. Si vous avez déjà joué avec le module de filetage, c'est très comparable. Les performances multiples de la tâche sont nécessaires. Nous devons importer le module multiprocesseur dans le script Python pour effectuer des opérations multiprocesses. Lorsque deux processus ou threads tentent d'accéder à une ressource partagée telle que les fichiers mémoire ou d'autres données, cela peut causer des problèmes dans le monde de la programmation. Ainsi, nous devons sécuriser cet accès à l'aide d'un verrouillage. Le partage de la mémoire et des accessoires principaux permettent aux unités de traitement d'exécuter les programmes simultanément.

L'application multiprocessement se divise en unités plus petites et fonctionne séparément. Le système d'exploitation attribue un processeur à chaque processus. Pour empêcher un autre processus d'exécuter une fonction équivalente jusqu'à la libération du verrouillage, nous utilisons la classe de verrouillage multiprocesseur pour obtenir un verrou sur le processus. La classe de verrouillage accomplit principalement deux fonctions. La méthode acquire () est utilisée pour d'abord obtenir un verrouillage, tandis que la fonction release () est utilisée pour libérer le verrouillage.

La mise en œuvre de Python du verrou () en multiprocesseur

Dans cet exemple, nous construisons un verrou, puis utilisons le module multiprocesseur pour utiliser la méthode Lock () après avoir créé deux processus. Nous pouvons générer et maintenir les nouvelles tâches enfants dans Python en utilisant le package multiprocesseur. Le composant multiprocessement facilite la création des processus à l'aide d'une interface similaire au composant de threading. Le module de multiprocessement prend en charge la concurrence locale et globale à l'aide de pièces individuelles plutôt que de threads, éliminant le verrouillage d'interprétation global. Python a une serrure mutex qui peut être utilisée avec plusieurs processus à la fois.verrouillage de la classe. Les processus peuvent construire, acquérir, puis libérer un objet du verrouillage avant d'accéder à une zone vitale.

Commençons maintenant à implémenter le code pour exécuter le script multiprocesseur Python. «Spyder» est également utilisé. Nous importons d'abord le module multiprocesseur. Nous devons importer le module de multiprocessement car nous devons créer un processus dans le script. Après cela, nous construisons une fonction définie par l'utilisateur appelé «fonction» et y passons l'argument «verrouillage» dans la ligne qui suit. La méthode acquire () est ensuite appelée avec la phrase «verrouillage» qui fournit une autorité de thread au-dessus d'un verrouillage. Un thread bloque jusqu'à ce que l'autre fil laisse tomber le verrou s'il essaie d'en acquérir un qui est déjà détenu par un autre fil. À ce moment, il rivalise avec tous les autres discussions qui cherchent à saisir la serrure. Un fil à la fois ne peut posséder que la serrure. L'instruction «Section importante» est ensuite adoptée comme entrée lorsque nous appelons «print ()» à l'étape suivante.

Ensuite, à l'étape suivante, nous appelons à nouveau la fonction «print ()», en le faisant passer l'expression «il ne peut y avoir qu'un seul processus à la fois» avant d'appeler la fonction «release ()» avec la fonction «Lock». Lorsqu'il est fait de cette manière, le verrou est toujours libéré même s'il y a un bogue ou une erreur dans la région cruciale, définissant clairement le début et la fin du code protégé.

Maintenant que nous avons défini une fonction avec le nom «Fonction Run», nous passons à la phase suivante où nous créons un processus, puis l'appelons en utilisant le module «Lock ()». Nous le gardons dans le paramètre de verrouillage et utilisons «Multiprocessement.Lock () ”pour appeler le verrou avec le processus. Maintenant que nous avons créé le processus 1, nous utilisons «le multiprocessement.processus »pour appeler la fonction dans ce processus. Nous passons également le verrouillage de l'argument à la fonction à l'aide du verrou «argu» = »et stockant le processus 1 dans la variable« p1 ».

Ensuite, à l'étape suivante, nous utilisons «le multiprocessement.processus »pour exécuter la fonction dans le processus 2 et passer la« fonction Target = »tout en le stockant dans la variable« p2 ». Le processus est ensuite commencé à utiliser la fonction "start ()" avec "p1" et "p2". À l'étape suivante, nous utilisons «join ()» avec «p1» et «p2» pour attendre que l'exécution du processus soit terminée. Ensuite, nous utilisons le «if name = main_», qui est essentiellement un point d'entrée. La "fonction run ()" est ensuite invoquée à la fin.

Pour ce faire, le processus doit d'abord acquérir le verrou avant d'exécuter la partie essentielle. Lorsque la phase critique de la tâche est terminée, le processus doit supprimer le verrouillage. Les deux processus et leurs déclarations ont été affichés. Il ne pouvait y avoir qu'une seule tâche exécutée à la fois présentée après la «section critique."

Nous avons maintenant un autre exemple de verrouillage multiprocesseur Python. Commençons par importer «dormir» à partir du module temporel avant d'importer «aléatoire» à partir du module aléatoire. Les entiers sont générés au hasard à l'aide d'un programme Python nommé Python Random. Parce qu'ils sont pseudo-aléatoires, ces nombres ne sont pas vraiment aléatoires. Vous pouvez utiliser ce package pour effectuer d'autres opérations aléatoires, imprimer un nombre aléatoire pour une liste ou une chaîne et générer les nombres aléatoires.

Ensuite, nous importons le processus du multiprocessement dans la ligne suivante. Le verrou est ensuite importé du multiprocessement. La fonction «func» est ensuite définie avec les arguments «verrouillage», «identifiant» et «val». Ensuite, nous utilisons un verrou pour obtenir le verrouillage. Cette partie cruciale implique de signaler un message et de bloquer un deuxième message.

En conséquence, nous exécutons la méthode print () dans le verrou, passant la déclaration avec les appels «identifiant» et «Val». La méthode «sleep ()» est utilisée pour suspendre l'exécution pour un nombre défini de secondes. Nous appelons ensuite «Val» dans ses parenthèses. Le verrou partagé est établi à l'aide de la méthode «Lock ()» et enregistré dans la variable «Lock» nouvellement créée lorsque nous utilisons la condition «if name = main_». Ensuite, nous utilisons la méthode Process () pour créer un processus, passant le «Target = Func» pour appeler la fonction dans le processus avec l'argument «Lock», le numéro construit «x» et le «aléatoire ()» fonction. Cette boucle se termine après avoir terminé ses itérations «15». Nous enregistrons ce processus dans la variable «P».

Ici, nous établissons également la gamme en utilisant «pour» et en définissant la gamme sur «15». Le processus commence maintenant par appeler le «processus.commencer()". Ensuite, nous appelons le processus avec la méthode «join ()» pour attendre l'exécution.

Lorsque l'exemple est exécuté, quinze processus sont démarrés et chacun est configuré pour utiliser notre fonction personnalisée. Après cela, le processus principal attend que chacun des processus enfants se termine avant de le lancer. Chaque processus d'enfant dans la méthode de la fonction () essaie de saisir le verrouillage. La serrure ne peut être obtenue que par un seul processus à la fois. Lorsque cela se produit, ils envoient un message comprenant leur identité et combien de temps ils prévoient de dormir ainsi que l'index est hors service car il est affiché dans la sortie dès que l'opération est terminée.

Conclusion

Nous avons appris le verrouillage multiprocesseur Python dans cet article. Le verrou est un concept fondamental de la théorie du système multiprocesseur et du système d'exploitation. Dans la première section de l'exemple, nous avons créé deux processus à l'aide d'un verrou et les avons appelés à l'aide d'un verrou pour exécuter la fonction que nous avons définie. Dans la section suivante du code, nous avons utilisé la boucle pour la plage sur «15» pour exécuter le processus. Le processus est terminé une fois qu'il termine ses itérations «15». Dans la deuxième section, nous avons également utilisé la technique «Sleep ()» pour retarder l'exécution pendant un court moment.