Python : Programmation Asynchrone - Historique des versions

Justine le 22 juin 2022 à 12:07

2022-06-22T12:07:40Z

← Version précédente		Version du 22 juin 2022 à 12:07
Ligne 1 :		Ligne 1 :
			[[Category:prog]]
			[[Category:python]]

	Les informations sont issues de [http://apprendre-python.com/page-programmation-asynchrone-python-thread-threading http://apprendre-python.com/page-programmation-asynchrone-python-thread-threading] et de [https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/2235545-la-programmation-parallele-avec-threading https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/2235545-la-programmation-parallele-avec-threading]		Les informations sont issues de [http://apprendre-python.com/page-programmation-asynchrone-python-thread-threading http://apprendre-python.com/page-programmation-asynchrone-python-thread-threading] et de [https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/2235545-la-programmation-parallele-avec-threading https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/2235545-la-programmation-parallele-avec-threading]

Justine le 5 juin 2022 à 09:52

2022-06-05T09:52:08Z

← Version précédente		Version du 5 juin 2022 à 09:52
Ligne 7 :		Ligne 7 :

	Je vais utiliser un script plus simple que celui du cours pour présenter ce concept. On va partir de ce script qui affiche les chiffres de 0 à 9, deux fois.		Je vais utiliser un script plus simple que celui du cours pour présenter ce concept. On va partir de ce script qui affiche les chiffres de 0 à 9, deux fois.
	<~~div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px"><pre~~>import threading		<nowiki>
			import threading
	import sys		import sys

Ligne 21 :		Ligne 22 :
	boucle2()		boucle2()

	</~~pre~~>		</nowiki>

	~~ ~~
	~~</div>~~
	Sans surprise, ce script émet les deux séries de nombres sur la sortie standard, dans l'ordre. On aurait pu passer par des prints ici, mais le fait d'utiliser la sortie standard se justifie lorsque l'on passe par du threading : les prints ne marchent plus, [je suppose] parce que les threads sont lancés dans un autre terminal?		Sans surprise, ce script émet les deux séries de nombres sur la sortie standard, dans l'ordre. On aurait pu passer par des prints ici, mais le fait d'utiliser la sortie standard se justifie lorsque l'on passe par du threading : les prints ne marchent plus, [je suppose] parce que les threads sont lancés dans un autre terminal?

	La version avec thread donne :		La version avec thread donne :
	<~~div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px"><pre~~>import threading		<nowiki>
			import threading
	import sys		import sys

Ligne 44 :		Ligne 44 :
	threading1.start() #...lancés par leur fonction start		threading1.start() #...lancés par leur fonction start
	threading2.start()		threading2.start()
	</~~pre~~>		</nowiki>
	~~</div>~~
	La sortie est intéressante:		La sortie est intéressante:
	<~~div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px"~~>		<nowiki>
	justine@Justine-pc:~$ python3 testthread.py~~<br/>~~ 0~~<br/>~~ 1~~<br/>~~ 0~~<br/>~~ 2~~<br/>~~ 1~~<br/>~~ 3~~<br/>~~ 4~~<br/>~~ 2~~<br/>~~ 3<~~br/> 5<br/> 6<br/> 7<br/> 8<br~~/> ~~9<br/> 4<br/> 5<br/> 6<br/> 7<br/> 8<br/> 9~~		justine@Justine-pc:~$ python3 testthread.py
	~~</div>~~		0
			1
			0
			2
			1
			3
			4
			2
			3
			#etc
			</nowiki>

	Les nombres ne sortent plus dans l'ordre ! Les deux threads sont lancés quasiment en même temps, et émettent en même temps.		Les nombres ne sortent plus dans l'ordre ! Les deux threads sont lancés quasiment en même temps, et émettent en même temps.

Ligne 55 :		Ligne 66 :

	Par exemple :		Par exemple :
	<~~div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px"><pre~~>import threading		<nowiki>
			import threading
	import sys		import sys
	from threading import RLock		from threading import RLock
Ligne 79 :		Ligne 91 :
	threading1.start()		threading1.start()
	threading2.start()</pre>		threading2.start()</pre>
	</~~div~~>		</nowiki>
	Ici, la sortie sera toujours boucle1, puis boucle2. Ici, on crée un objet RLock nommé verrou. Ensuite, on passe cet objet à chacune de nos fonction via un context manager (un cours là-dessus devrait suivre). Chaque fonction ne pourra s'exécuter que si elle peut verrouiller le lock, ce qui n'est possible qu'une seule fonction à la fois.		Ici, la sortie sera toujours boucle1, puis boucle2. Ici, on crée un objet RLock nommé verrou. Ensuite, on passe cet objet à chacune de nos fonction via un context manager (un cours là-dessus devrait suivre). Chaque fonction ne pourra s'exécuter que si elle peut verrouiller le lock, ce qui n'est possible qu'une seule fonction à la fois.

Justine le 26 juillet 2019 à 15:31

2019-07-26T15:31:49Z

← Version précédente		Version du 26 juillet 2019 à 15:31
Ligne 81 :		Ligne 81 :
	</div>		</div>
	Ici, la sortie sera toujours boucle1, puis boucle2. Ici, on crée un objet RLock nommé verrou. Ensuite, on passe cet objet à chacune de nos fonction via un context manager (un cours là-dessus devrait suivre). Chaque fonction ne pourra s'exécuter que si elle peut verrouiller le lock, ce qui n'est possible qu'une seule fonction à la fois.		Ici, la sortie sera toujours boucle1, puis boucle2. Ici, on crée un objet RLock nommé verrou. Ensuite, on passe cet objet à chacune de nos fonction via un context manager (un cours là-dessus devrait suivre). Chaque fonction ne pourra s'exécuter que si elle peut verrouiller le lock, ce qui n'est possible qu'une seule fonction à la fois.

			= Des sous-routine avec async / await =
			[[https://medium.com/velotio-perspectives/an-introduction-to-asynchronous-programming-in-python-af0189a88bbb]]

			Deux mots-clef ici :
			*async : sert à définir une fonction comme asynchrone, c'est à dire qu'elle va pouvoir générer des sous-routines et recevoir leur réponse (elle fera autre chose en attendant)
			*await : sert à lancer une sous-routine.

			C'est assez utile pour faire des sous-threads sans import le module Threading.

			Exemple :

			<nowiki>

			async def truc():
			bidule()
			await machine_asynchrone() #Lancer la sous-routine qui consiste à exécuter la fonction machine_asynchrone()
			chose()

			</nowiki>

Justine : Page créée avec « Les informations sont issues de [http://apprendre-python.com/page-programmation-asynchrone-python-thread-threading http://apprendre-python.com/page-programmation-a... »

2018-11-25T21:01:17Z

Page créée avec « Les informations sont issues de [http://apprendre-python.com/page-programmation-asynchrone-python-thread-threading http://apprendre-python.com/page-programmation-a... »

Nouvelle page

 
Les informations sont issues de [http://apprendre-python.com/page-programmation-asynchrone-python-thread-threading http://apprendre-python.com/page-programmation-asynchrone-python-thread-threading] et de [https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/2235545-la-programmation-parallele-avec-threading https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python/2235545-la-programmation-parallele-avec-threading]
La programmation asynchrone permet de lancer plusieurs processus en simultané, en lançant plusieurs instructions en même temps. Cela peut permettre de gagner du temps.

Cela passe par le module threading.

Je vais utiliser un script plus simple que celui du cours pour présenter ce concept. On va partir de ce script qui affiche les chiffres de 0 à 9, deux fois.
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px"><pre>import threading
import sys

def boucle1():
for i in range(10):
sys.stdout.write(str(i) + "\n")

def boucle2():
for i in range(10):
sys.stdout.write(str(i) + "\n")

boucle1() #Les deux fonctions sont lancées l'une après l'autre
boucle2()

</pre>

 
</div>
Sans surprise, ce script émet les deux séries de nombres sur la sortie standard, dans l'ordre. On aurait pu passer par des prints ici, mais le fait d'utiliser la sortie standard se justifie lorsque l'on passe par du threading : les prints ne marchent plus, [je suppose] parce que les threads sont lancés dans un autre terminal?

La version avec thread donne :
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px"><pre>import threading
import sys

def boucle1():
for i in range(10):
sys.stdout.write(str(i) + "\n")

def boucle2():
for i in range(10):
sys.stdout.write(str(i) + "\n")

threading1 = threading.Thread(target=boucle1, args=()) #Les threads sont des objets
threading2 = threading.Thread(target=boucle2, args=())

threading1.start() #...lancés par leur fonction start
threading2.start()
</pre>
</div>
La sortie est intéressante:
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px">
justine@Justine-pc:~$ python3 testthread.py<br/> 0<br/> 1<br/> 0<br/> 2<br/> 1<br/> 3<br/> 4<br/> 2<br/> 3<br/> 5<br/> 6<br/> 7<br/> 8<br/> 9<br/> 4<br/> 5<br/> 6<br/> 7<br/> 8<br/> 9
</div>
Les nombres ne sortent plus dans l'ordre ! Les deux threads sont lancés quasiment en même temps, et émettent en même temps.

D'autres essais, fait en modifiant le script pour qu'il affiche la boucle dont est issue le string affiché, montrent que parfois les sorties sont dans l'ordre, et parfois non. Il peut alors être important de tenir compte du fait que les deux threads ne sont pas forcément synchronisés. C'est là l'utilité des RLocks, qui permettent de verrouiller un thread ou une partie d'un thread : la partie verrouillée d'un thread ne pourra s'exécuter qu'un seul thread à la fois.

Par exemple :
<div style="background:#eeeeee; border:1px solid #cccccc; padding:5px 10px"><pre>import threading
import sys
from threading import RLock

verrou = RLock()

def boucle1():
with verrou:
for i in range(10):
sys.stdout.write("Boucle1" + "\n")

def boucle2():
with verrou:
for i in range(10):
sys.stdout.write("Boucle2" + "\n")

#boucle1() #Les deux fonctions sont lancées l'une après l'autre
#boucle2()

threading1 = threading.Thread(target=boucle1, args=())
threading2 = threading.Thread(target=boucle2, args=())

threading1.start()
threading2.start()</pre>
</div>
Ici, la sortie sera toujours boucle1, puis boucle2. Ici, on crée un objet RLock nommé verrou. Ensuite, on passe cet objet à chacune de nos fonction via un context manager (un cours là-dessus devrait suivre). Chaque fonction ne pourra s'exécuter que si elle peut verrouiller le lock, ce qui n'est possible qu'une seule fonction à la fois.

Python : Programmation Asynchrone - Historique des versions

Justine le 22 juin 2022 à 12:07

Justine le 5 juin 2022 à 09:52

Justine le 26 juillet 2019 à 15:31

Justine : Page créée avec « Les informations sont issues de [http://apprendre-python.com/page-programmation-asynchrone-python-thread-threading http://apprendre-python.com/page-programmation-a... »

Justine : Page créée avec « Les informations sont issues de [http://apprendre-python.com/page-programmation-asynchrone-python-thread-threading http://apprendre-python.com/page-programmation-a... »