Développement Python – explication détaillée des processus, des threads et des coroutines

Qu'est-ce qu'un processus ?

Un programme ne peut pas s'exécuter seul. Ce n'est que lorsque le programme est chargé en mémoire et que le système lui alloue des ressources qu'il peut s'exécuter. Ce programme exécuté est appelé un processus. La différence entre un programme et un processus est qu'un programme est un ensemble d'instructions, qui est un texte de description statique du processus. Un processus est une activité d'exécution du programme et est un concept dynamique.

Qu'est-ce qu'un fil de discussion ?

Thread est la plus petite unité sur laquelle le système d'exploitation peut effectuer la planification des opérations. Il est inclus dans le processus et constitue la véritable unité opérationnelle du processus. Un thread fait référence à un seul flux de contrôle séquentiel dans un processus. Plusieurs threads peuvent s'exécuter simultanément dans un processus et chaque thread exécute différentes tâches en parallèle.

Quelle est la différence entre un processus et un thread ?

Les threads partagent l'espace mémoire et la mémoire du processus est indépendante.

Les threads d'un même processus peuvent communiquer directement entre eux, mais deux processus doivent communiquer entre eux via un agent intermédiaire.

Créer un nouveau thread est très simple. Créer un nouveau processus nécessite de cloner son processus parent.

Un thread peut contrôler et faire fonctionner d'autres threads dans le même processus, mais un processus ne peut faire fonctionner que des processus enfants.

Python GIL (Global Interpreter Lock)

Peu importe le nombre de threads ouverts et le nombre de processeurs, python n'autorise qu'un seul thread en même temps lors de l'exécution.

Module de threading Python

appelle directement

1. import threading, time
3. def run_num(num):
4. """
5. Définir la fonction à exécuter par le fil
6. :param num:
7. :retour:
8. """
9. print("en cours d'exécution sur le numéro :%s"%num)
10. time.sleep(3 )
12. if __name__ == '__main__':
13. # Générer une instance de thread t1
14. t1 = threading.Thread(target=run_num,args=( 1,) )
15. # Générer une instance de thread t2
16. t2 = threading. Sujet(target =run_num,args=(2,))
17.  ​ # Démarrer le fil de discussion t1
18. t1.start()
19. # Démarrer le fil de discussion t2
20. t2 .start()
21. # Obtenez le nom du fil de discussion
22. print(t1.getName ())
23. print(t2.getName())
24. Sortie :
25. en cours d'exécution sur le numéro :1
26. en cours d'exécution sur le numéro :2
27. Thread-1
28. Thread-2

Appel hérité

1. fil d'importation, heure
3. class MyThread(threading.Thread):
4. def __init__(self,num ):
5. threading.Thread.__init__(self)
6. self.num = num
7. ​ # Définir la fonction à exécuter par chaque thread Le nom de la fonction doit être exécuté
8. <.>
   def run(self):
9. print("en cours d'exécution sur le numéro :%s"%self.num)
10. time.sleep(3)
12. if __name__ == '__main__':
13. t1 = MonThread(1)
14. t2 = MonThread(2)
15. t1.start()
16. t2.start()
17. Sortie :
18. exécuté sur le numéro : 1
19. exécuté sur le numéro :2

Rejoindre et démon

Rejoindre

La fonction de Join est de bloquer le processus principal et ne peut pas exécuter le programme après la jointure.

Dans le cas de multi-threads et de jointures multiples, les méthodes de jointure de chaque thread sont exécutées en séquence. L'exécution du thread précédent est terminée avant que le thread suivant puisse être exécuté.

Lorsqu'il n'y a aucun paramètre, attendez la fin du thread avant d'exécuter les programmes suivants.

Après avoir défini les paramètres, attendez le temps défini par le thread, puis exécutez le processus principal suivant, que le thread se termine ou non.

1. importer le fil, l'heure
3. class MyThread(threading.Thread):
4. def __init__(self,num):
5.                                                                                         threading.Thread.__init__(self) # Définissez la fonction à exécuter par chaque thread. Le nom de la fonction doit être exécuté
6. def run(self):
7. print("fonctionnant sur le numéro :%s
   "%self. num)
8. time.sleep(3)
9. print(" fil de discussion :%s
   "%self.num)
11. si __name__ == '__main__' :
12. t1 = MonThread(1)
13. t2 = MonThread(2)
14. t1.start()
15. t1.join( )
16.     t2.start()
17.     t2.join()
18. 输出：
19. fonctionne sur le numéro :1
20. thread:1
21. en cours d'exécution sur le numéro:2
22. thread:2

设置参数效果如下：

1. if __name__ == '__main__':
2.     t1 = MonThread(1)
3.     t2 = MonThread(2)
4.     t1.start()
5.     t1.join(2)
6.     t2.start()
7.     t2.join()
8. 输出：
9. en cours d'exécution sur le numéro :1
10. en cours d'exécution sur le numéro :2
11. fil :1
12. fil :2

Démon

有子线程的结束。如果希望主线程不等待子线程，而是在退出时自动Il s'agit d'un démon (démon). 🎜>

1. temps d'importation,threading
3. def run(n):
4.     print("%s".center(20,"*")%n)
5.     time.sleep(2)
6.     print("done".center(20,"*" ))
8. def main() :
9.     pour i dans plage(5) :
10.         t = threading.Thread(target =run,args=(i,))
11.         t.start()
12.         t.join(1)
13.         print("fil de discussion",t.getName())
15. m = threading.Thread(target=main,args=())
16. # 将main线程设置位Daemon线程，它作为程序主线程的守护线程，当主线程退出时，m线程也会退出，由m启动的其它子线程会同时退出，不管是否执行完成
17. m.setDaemon(True)
18. m.start()
19. m.join(3)
20. print("thème principal terminé". center(20,"*"))
21. Sortie :
22. ************0************
23. démarrage du fil de discussion- 2
24. ************1**********
25. ********terminé************
26. démarrage du fil de discussion -3
27. *********2************
28. **thread principal terminé **

Thread lock (Mutex)

Plusieurs threads peuvent être démarrés sous un seul et plusieurs threads partagent l'espace mémoire du processus parent. Cela signifie que chaque thread peut accéder aux mêmes données. À ce stade, si deux threads souhaitent modifier les mêmes données en même temps, un verrouillage de thread est requis.

1. temps d'importation, threading
3. def addNum():
4. # Obtenez cette variable globale dans chaque fil
5. numéro global
6. print("--get num:",num)
7. time.sleep(1)
8. # Effectuer une opération -1 sur cette variable publique
9. num -= 1
10. # Définir une variable partagée
11. num = 100
12. thread_list = []
13. pour je dans plage(100) :
14. t = threading.Thread(target=addNum)
15. t.start()
16. thread_list.append(t)
17. # Attendez que tous les threads terminent leur exécution
18. for t in thread_list :
19. t.join()
21. print("final num:",num)

Version verrouillée

Le verrouillage empêche les autres threads de partager l'accès aux ressources, et le même thread ne peut acquérir qu'une seule fois. S'il y en a plusieurs, un blocage se produira et le programme ne pourra pas continuer à s'exécuter.

1. temps d'importation, threading
3. def addNum():
4. # Obtenez cette variable globale dans chaque fil
5. numéro global
6. print("--get num:",num)
7. time.sleep(1)
8. # Verrouiller avant de modifier les données
9. lock.acquire()
10. # Effectuer une opération -1 sur cette variable publique
11. num -= 1
12. # Libération après modification
13. lock.release()
14. # Définir une variable partagée
15. num = 100
16. thread_list = []
17. # Générer un verrou global
18. lock = threading.Lock()
19. pour je dans plage ( 100) :
20. t = threading.Thread(target=addNum)
21. t .start()
22. thread_list.append(t)
23. # Attendez tout Exécution du fil terminée
24. pour t dans thread_list :
25. t.join()
27. print("numéro final : ",num)

GIL VS Lock

GIL garantit qu'un seul thread peut s'exécuter en même temps. Le verrouillage est un verrouillage au niveau de l'utilisateur et n'a rien à voir avec GIL.



RLock (verrouillage récursif)

Rlock permet de multiples acquisitions dans un même thread La libération des ressources partagées par un thread nécessite la libération de tous les verrous. Autrement dit, n fois d’acquisition nécessitent n fois de libération.

1. def run1():
2. print("récupérez les données de la première partie")
3.  lock.acquire()
4. num global
5. num += 1
6. verrouillage .release()
7.  return num
9. def run2():
10. print("récupérez les données de la deuxième partie")
11.  lock.acquire()
12. global num2
13. num2 += 1
14. lock.release()
15.  retour num2
17. def run3() :
18.      lock.acquire()
19.     res = run1()
20.     imprimer ("entre run1 et run2".center(50,"*"))
21.     res2 = run2 ()
22.     lock.release()
23.     imprimer (res,res2)
25. if __name__ == '__main__' :
26.     num,num2 = 0,0
27.     lock = threading.RLock()
28.     pour i dans plage (10) :
29.         t = threading.Thread(target=run3)
30.         t.start()
32. pendant threading.active_count() != 1:
33.     print(threading.active_count())
34. else:
35.     print("tous les fils de discussion terminés".center(50,"*"))
36.     print(num,num2)

这两种锁的主要区别是，RLock允许在同一线程中被多次acquire。而Lock Il s'agit d'un système RLock qui permet d'acquérir une version et d'une version n.能真正释放所占用的锁。

Sémaphore （信号量）

互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据，比如售票处有3个窗口，那最多只允许3个人同时买票， 后面 的 人 只 能 等 前面 任意 窗口 的 人 离开 才 能 买 票。。

1. Importer du threading, du temps
3. def run(n):
4.     semaphore.acquire()
5.     time.sleep(1)
6.     print("lancer le fil :%s"%n)
7.     semaphore.release()
9. if __name__ == '__main__':
10.     # 最多允许5个线程同时运行
11.     sémaphore = threading.BoundedSemaphore(5)
12.     pour je dans plage(20):
13. t = threading.Thread(target=run,args=(i,))
14. t.start ()
16. while threading.active_count() != 1 :
17. # print(threading.active_count())
18. passe
19. else:
20. print("tous les fils de discussion sont terminés ".center(50,"*"))

Timer (timer)

Timer appelle une fonction à un certain intervalle , si vous souhaitez appeler une fonction de temps en temps, vous devez redéfinir le Timer dans la fonction appelée par le Timer. Timer est une classe dérivée de Thread.

1. importer du thread
3. def bonjour( ):
4. print("bonjour tout le monde !")
5. # Exécuter la fonction bonjour après un délai de 5 secondes
6. t = threading.Timer(5,hello)
7. t.start()

Event

Python fournit l'objet Event pour la communication inter-thread, qui a des paramètres de thread Si l'indicateur de signal est faux, le thread attend que le signal d'instruction soit défini sur vrai par d'autres threads. L'objet Event implémente un mécanisme de communication de thread simple. Il fournit des signaux de configuration, d'effacement, d'attente, etc. pour réaliser la communication entre les threads.

1. Définir le signal

Utilisez la méthode set() de Event pour définir l'indicateur de signal à l'intérieur de l'objet Event sur true. L'objet Event fournit la méthode isSet() pour déterminer l'état de son indicateur de signal interne. Lorsque la méthode set() de l'objet événement est utilisée, la méthode isSet() renvoie true.

1. Effacer le signal

Utilisez la méthode clear() de Event pour effacer l'indicateur de signal à l'intérieur de l'objet Event, c'est-à-dire le définir sur false Lors de l'utilisation de la méthode clear() d'After Event, la méthode isSet() renvoie false.

1. Waiting

La méthode wait() de l'événement ne s'exécutera rapidement et terminera le retour que lorsque le signal interne est vrai. Lorsque l'indicateur de signal interne de l'objet Event est faux, la méthode wait() attend qu'il soit vrai avant de revenir.

Utilisez Event pour réaliser l'interaction entre deux ou plusieurs threads. Prenons le feu de signalisation comme exemple, démarrez un fil pour agir comme un feu de circulation, générez plusieurs threads pour agir comme des véhicules, et le. les véhicules s'arrêteront selon la règle rouge et verte.

1. importer le thread, le temps, aléatoire
3. def light():
4.  if pas event.isSet():
5.  événement.set()
6. compte = 0
7.  pendant Vrai :
8.  si compte < 5 :
9. print("
10.         nombre d'elif < 8 :
11.             print(" 33[43;1m--lumière jaune allumée-- 33[0m".center(50, "*"))
12.         elif count < 13 :
13.             ifévénement.isSet():
14.                 event.clear()
15.             print(" 33[41;1m--rouge lumière allumée-- 33[0m".center(50,"*"))
16.         else :
17.             count = 0
18.             événement. set()
19.         time.sleep(1)
20.         compte += 1
23. voiture def( n):
24.     pendant 1 :
25.         heure. sleep(random.randrange(10))
26.         ifevent.isSet():
27.             print("la voiture %s roule..."%n)
28.         else:
29.             print("la voiture %s attend le feu rouge... "%n)
31. if __name__ == "__main__":
32.     event = threading.Event()
33.     Light = threading.Thread(target=light,)
34.     Light.start()
36.     pour i dans plage(3) :
37.         t = threading.Thread(target=car,args=(i,))
38.         t.start()

file d'attente

La file d'attente en Python est la forme la plus couramment utilisée pour échanger des données entre les threads. Le module Queue est un module qui fournit des opérations de file d'attente.

Créer un objet de file d'attente

1. file d'attente d'importation
3. q = queue.Queue(maxsize = 10)

La classe queue.Queue est une implémentation synchrone d'une file d'attente. La longueur de la file d'attente peut être illimitée ou limitée. La longueur de la file d'attente peut être définie via le paramètre facultatif maxsize du constructeur Queue. Si maxsize est inférieur à 1, la longueur de la file d'attente est illimitée.

Mettre une valeur dans la file d'attente

1. q.put("a")

Appelez la méthode put() de l'objet file d'attente pour insérer un élément à la fin de la file d'attente. put() a deux paramètres : le premier élément est obligatoire et est la valeur de l'élément inséré ; le deuxième bloc est un paramètre facultatif et sa valeur par défaut est 1. Si la file d'attente est actuellement vide et que le bloc vaut 1, la méthode put() provoque la pause du thread appelant jusqu'à ce qu'une unité de données devienne disponible. Si block vaut 0, la méthode put() lèvera une exception Full.

Supprimer une valeur de la file d'attente

1. q.get()

L'appel de la méthode get() de l'objet file d'attente supprime et renvoie un élément de la tête de la file d'attente. Le paramètre facultatif est block, dont la valeur par défaut est True. Si la file d'attente est vide et que block est True, get() provoque la pause du thread appelant jusqu'à ce qu'un élément devienne disponible. Si la file d'attente est vide et que le bloc est False, la file d'attente lèvera une exception vide.

Le module Python Queue comporte trois files d'attente et constructeurs

1. # Premier entré, premier sorti
2. class queue.Queue(maxsize=0)
3. # Premier entré, dernier sorti
4. class queue.LifoQueue(maxsize=0)
5. # Plus la file d'attente prioritaire est basse niveau, le premier il sort
6. class queue.PriorityQueue(maxsize=0)

Méthodes courantes

1. q = queue.Queue()
2. # Retour la taille de la file d'attente
3. q.qsize()
4. # Si la file d'attente est vide, renvoie True, sinon False
5. q.empty()
6. # Si la file d'attente est pleine, renvoie True, sinon False
7. q.full()
8. # Récupérer la file d'attente, délai d'attente
9. q.get([block[,timeout]])
10. # Équivalent à q.get(False)
11. q.get_nowait ()
12. # Attendez que la file d'attente soit vide avant d'effectuer d'autres opérations
13. q .join()

Modèle producteur-consommateur

L'utilisation des modèles de producteur et de consommateur dans le développement et la programmation peut résoudre la plupart des problèmes de concurrence. Ce mode améliore la vitesse globale de traitement des données du programme en équilibrant les capacités de travail du thread de production et du thread consommateur.

Pourquoi utiliser les modèles de producteur et de consommateur

Dans le monde des threads, le producteur est le fil qui produit des données, et le consommateur est le fil qui consomme des données. Dans le développement multithread, si la vitesse de traitement du producteur est très rapide et celle du consommateur est très lente, alors le producteur doit attendre que le consommateur ait terminé le traitement avant de continuer à produire des données. De la même manière, si la puissance de traitement du consommateur est supérieure à celle du producteur, alors le consommateur doit attendre le producteur. Afin de résoudre ce problème, les modèles producteur et consommateur ont été introduits.

Qu'est-ce que le modèle producteur-consommateur ?

Le modèle producteur-consommateur utilise un conteneur pour résoudre le problème du couplage fort entre producteurs et consommateurs. Les producteurs et les consommateurs ne communiquent pas directement entre eux, mais via des files d'attente de blocage. Par conséquent, une fois que le producteur a produit les données, il n'attend plus que le consommateur les traite, mais les jette directement dans la file d'attente de blocage. demandez des données au producteur, mais prenez-les directement à partir de la file d'attente de blocage. La file d'attente de blocage est équivalente à un tampon, équilibrant les capacités de traitement des producteurs et des consommateurs.

L'exemple le plus basique du modèle producteur-consommateur.

1. file d'attente d'importation, threading, heure
3. q = queue.Queue(maxsize=10)
5. def Producer() :
6. compte = 1
7. pendant Vrai :
8. q.put("Os %s"%count)
9. print( "Os produit",count)
10. count += 1
12. def Consommateur(nom):
13.  pendant q.qsize ( ) > 0 :
14. print("[%s] a obtenu [%s] et l'a mangé... "%( nom,q.get()))
15. time.sleep(1)
17. p = threading.Thread(target=Producteur,)
18. c1 = threading.Thread(target=Consumer,args=("Wangcai",))
19. c2 = threading.Thread (target=Consumer ,args=("来福",))
20. p.start()
21. c1.start()
22. c2.start()