Exemples multi-processus et multi-thread en Python (2) Méthodes de programmation

Dans le chapitre précédent, nous avons appris quelques méthodes de base de la programmation multi-processus Python : utiliser les classes Process, Pool, Queue, Lock, Pipe et d'autres classes fournies par le module multi-processus multiplateforme multiprocessing pour implémenter des sous-processus. création, pool de processus (batch) Créer des processus enfants et gérer le nombre maximum de processus enfants) et communication inter-processus. Dans ce chapitre, vous découvrirez les méthodes de programmation multithread en Python.

1. Threading

Le thread est la plus petite unité permettant au système d'exploitation d'effectuer des tâches. Le module de threading est fourni dans la bibliothèque standard Python, qui offre une prise en charge très pratique pour la programmation multithread.

Voici le code pour implémenter le multi-threading à l'aide du threading :

 1 #!/usr/bin/python 2 # -*- coding: utf-8 -* 3 author = 'zni.feng' 4 import  sys 5 reload (sys) 6 sys.setdefaultencoding('utf-8') 7  8 import threading, time 9 10 def test(index):11     print time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))12     print 'thread %s starts.' % threading.current_thread().name13     print 'the index is %d' % index14     time.sleep(3)15     print time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))16     print 'thread %s ends.' % threading.current_thread().name17 18 if name == "main":19     print time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))20     print 'thread %s starts.' % threading.current_thread().name21     #创建线程22     my_thread = threading.Thread(target = test, args=(1,) , name= 'zni_feng_thread')23     #等待2s24     time.sleep(2)25     #启动线程26     my_thread.start()27     #等待线程结束28     my_thread.join()29     print time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))30     print 'thread %s ends.' % threading.current_thread().name

Le résultat de sortie est :

2017-01-12 22:06:32
thread MainThread starts.
2017-01-12 22:06:34
thread zni_feng_thread starts.
the index is 1
2017-01-12 22:06:37
thread zni_feng_thread ends.
2017-01-12 22:06:37
thread MainThread ends.
[Finished in 5.1s]

Parmi eux, le current_thread() la fonction du module de threading renverra l'instance du thread actuel.

2. Lock

La plus grande différence entre multi-processus et multi-thread est qu'en multi-processus, la même variable a une copie dans chaque processus. ne s'influencent pas mutuellement. En multi-threading, toutes les variables sont partagées par tous les threads, donc toute variable partagée peut être modifiée par n'importe quel thread. Par conséquent, le plus grand danger du partage de données entre threads est que plusieurs threads modifient une variable en même temps. Afin de résoudre ce problème, nous pouvons utiliser la classe Lock du module de threading pour verrouiller les variables partagées.

Regardons d'abord un exemple d'utilisation de plusieurs threads pour écrire la même variable partagée sans verrouillage :

 1 #!/usr/bin/python 2 # -*- coding: utf-8 -* 3 author = 'zni.feng' 4 import  sys 5 reload (sys) 6 sys.setdefaultencoding('utf-8') 7 import threading 8  9 class Account:10     def init(self):11         self.balance = 012 13     def add(self):14         for i in range(0,100000):15             self.balance += 116 17     def delete(self):18         for i in range(0,100000):19             self.balance -=1 
20 21 if name == "main":22     account  = Account()23     #创建线程24     thread_add = threading.Thread(target=account.add, name= 'Add')25     thread_delete = threading.Thread(target=account.delete, name= 'Delete')26 27     #启动线程28     thread_add.start()29     thread_delete.start()30     31     #等待线程结束32     thread_add.join()33     thread_delete.join()34 35     print 'The final balance is: ' + str(account.balance)

Le résultat en cours d'exécution est :

The final balance is: -51713
[Finished in 0.1s]

Il peut on constate qu'à chaque fois que vous l'exécutez, son résultat final sera différent et il ne sera pas 0. En effet, des conflits se produisent lorsque différents threads modifient la même variable en même temps et que certaines variables intermédiaires ne sont pas utilisées dans l'ordre.

Maintenant, nous utilisons Lock pour verrouiller le programme :

 1 #!/usr/bin/python 2 # -*- coding: utf-8 -* 3 author = 'zni.feng' 4 import  sys 5 reload (sys) 6 sys.setdefaultencoding('utf-8') 7 import threading 8  9 class Account:10     def init(self):11         self.balance = 012 13     def add(self, lock):14         #获得锁15         lock.acquire()16         for i in range(0,100000):17             self.balance += 118         #释放锁19         lock.release()20 21     def delete(self, lock):22         #获得锁23         lock.acquire()24         for i in range(0,100000):25             self.balance -=1 
26         #释放锁27         lock.release()28 29 30 if name == "main":31     account  = Account()32     lock = threading.Lock()33     #创建线程34     thread_add = threading.Thread(target=account.add, args=(lock, ), name= 'Add')35     thread_delete = threading.Thread(target=account.delete, args=(lock, ), name= 'Delete')36 37     #启动线程38     thread_add.start()39     thread_delete.start()40     41     #等待线程结束42     thread_add.join()43     thread_delete.join()44 45     print 'The final balance is: ' + str(account.balance)

On peut constater que peu importe le nombre de fois qu'il est exécuté, le résultat du solde est 0. Si vous imprimez les résultats de chaque calcul de solde, vous constaterez également que lorsqu'un thread commence à s'exécuter, l'autre thread attendra que le thread précédent ait fini de s'exécuter (pour être précis, lock.release() ait fini de s'exécuter) avant de commencer. . mettre en œuvre.

The final balance is: 0
[Finished in 0.1s]

[Recommandations associées]

1. Exemples de multi-processus et multi-threading en Python (1)

2. 🎜>Python Est-il recommandé d'utiliser le multi-traitement au lieu du multi-threading ? Partagez les raisons pour lesquelles il est recommandé d'utiliser le multi-processus

3

Le multi-processus ou le multi-thread sont-ils plus rapides en python ?

4.

Introduction détaillée aux processus, threads et coroutines Python

5

Pool de threads/pool de processus de programmation simultanée <.>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!