Exécuter 2 fonctions en parallèle simplement
Bonjoouur !
Ça fait depuis ce midi que j'essaie de comprendre comment marche l'asynchrone en python, et je comprends RIEN.
Donc tout simplement, est-ce que qqn peut juste me montrer un code pour exécuter les fonctions a() et b() en même temps ici, svp ? (Jsp si faut les définir async ou pas) C tout ce que je veux faire :3
Code:
1
2
3
4
5
6
7
8
9
| import time
def a():
time.sleep(3)
print("a() terminé")
def b():
time.sleep(5)
print("b() terminé") |
Donc ça devrais faire :
(Après 3 secondes)
a() terminé
(Après 2 secondes)
b() terminé
Merci d'avance ! ^^'
Re Execution de 2 fonctions en parrallèle
Bonjour,
Je connais deux modules dans la bibliothèque standart permettant de gérer l’exécution asynchrone: multiprocessing et threading.
La différence fondamentale entre les deux est que le module threading ne gère que le monocœur tendis que multiprocessing permet de paralléliser l'exécution sur plusieurs cœurs.
Un thread est un ensemble d'instruction qui s’exécutera comme une tache autonome sur un coeur donné. En python la classe permettant d'y accéder est Thread.
On peut créer on thread de la manière suivante :
thread = Thread(nom_de_la_fonction, args=(argument1, arguments2..))
On execute avec start()
on attend la fin de l’exécution avec join()
Une seconde solution est d’hériter de la classe Thread et de surcharger la méthode run() qui sera appelée par start()
L' équivalent multiprocessing du Thread et le Process il peut être appelé de la même manière.
Les modules sont très complets et la documentation est de bonne qualité si tu souhaites approfondir.
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
from threading import Thread
from multiprocessing import Pool
import time
def a(time_to_sleep,message):
"""
:param time_to_sleep: (Double) the time in sec
:param message: (String) the message to return
"""
t1 = time.time()
time.sleep(time_to_sleep)
print(message, time.time()-t1)
class MonThread(Thread):
def __init__(self, time_to_sleep, message):
super(MonThread, self).__init__()
self.time_to_sleep = time_to_sleep
self.message = message
def run(self):
t1 = time.time()
time.sleep(self.time_to_sleep)
print(self.message, time.time() - t1)
if __name__ == '__main__':
thread1=Thread(target=a,args=(3, "thread1 termine"))
thread2=Thread(target=a,args=( 6, "thread2 termine"))
thread1.start()
thread2.start()
print("le thread principal continue")
thread1.join()
print('j attend la fin du thread 1')
thread2.join()
print('j attend a fin du thread 2')
print("par classe")
thread1= MonThread(2, "thead3")
thread2 = MonThread(4, "thread4")
thread2.start()
thread1.start()
thread2.join()
thread1.join()
print("fin")
print("multiprocess")
# La fonction Pool est une méthode simple pour faire plusieurs fois la même fonction avec des arguments différents
with Pool(2)as p:
p.starmap(a, [(1, "01"), (2, '02')]) |
