Utiliser le module threading : fonctionnement étrange

**UnCurieux** · 17/06/2019, 16h10

Bonjour,

j'ai un algorithme en Python 3.7 avec IDLE :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from threading import Thread,RLock
from math import sqrt
 
verrou=RLock()
 
class testthread(Thread):
 
    def __init__(self,debut,fin):
        Thread.__init__(self)
        self.debut=debut
        self.fin=fin
 
    def run(self):
        a=1
        for i in range(self.debut,self.fin):
          l,d,n=1,2,i
          while n>1:
            if n%d==0:
              l=d
              n/=d
            else:
              d+=1
          if l<sqrt(i):
            with verrou:
              a+=1
        print(a)
 
# Création des threads
thread_1 = testthread(1,500)
thread_2 = testthread(500,10001)
#thread_3 = testthread(500,750)
#thread_4 = testthread(750,1001)
 
# Lancement des threads
thread_1.start()
thread_2.start()
#thread_3.start()
#thread_4.start()
 
# Attend que les threads se terminent
thread_1.join()
thread_2.join()
#thread_3.join()
#thread_4.join()

Peu importe ce qu'il calcule exactement, vous voyez qu'il s'agit d'une structure basique pour l'utilisation de thread.

Mon problème est que je croyais que thread permettait de faire de la programmation parallèle, c'est-à-dire faire fonctionner le même algorithme plusieurs fois mais en même temps.
Ici je crois qu'il devrait faire tourner for de 1 à 500 et de 500 à 1000 en même temps, mais ce n'est pas ce qui se passe : on dirait qu'il calcule d'abord thread_1 puis thread_2 !
Si quelqu'un pouvait m'aider à effectuer cette boucle plusieurs fois en même temps ce serait génial

**wiztricks** · 17/06/2019, 17h54

Salut,

Envoyé par UnCurieux

on dirait qu'il calcule d'abord thread_1 puis thread_2 !

A cause du GIL, vos threads ne seront jamais actives toutes les deux en même temps. Cà n'ira pas plus vite sauf à utiliser multiprocessing.

- W

**UnCurieux** · 17/06/2019, 18h46

Je vois, malheureusement je me suis orienté vers threading justement après avoir échoué à utiliser multiprocessing. Je n'y arrive pas du tout. Là j'ai appris les bases de threading aujourd'hui.

Peut-être pourriez-vous m'indiquer un bon tuto pour utiliser multiprocessing ?
Car mon but originel est simplement de pouvoir effectuer des boucles jusqu'à 10 milliards par exemple, très rapidement.

**wiztricks** · 17/06/2019, 19h42

Salut,

Envoyé par UnCurieux

Peut-être pourriez-vous m'indiquer un bon tuto pour utiliser multiprocessing ?

La documentation contient un minimum d'exemple pour vous permettre de démarrer. Après, vu tout ce qu'on peut faire avec, il faut chercher un peu sur Internet pour voir ce qui se rapproche de ce que vous voulez faire (et avoir des idées sur d'autres possibilités).

Envoyé par jmbain

On voit que les threads s'exécutent "plus ou moins" en même temps, ce qui est le but recherché.

Si vous effectuez une IO au milieu d'un calcul, le thread courant attendra la fin de l'IO et le thread en attente de CPU pourra avancer.
De toutes façons, si on parallélise, c'est pour aller "plus vite" i.e. avoir une durée de traitement plus courte. Idéalement si çà prend N secondes pour faire les calculs avec un seul thread, on espère que çà pendra N/2 avec 2 threads, N/3 avec 3 threads,... jusqu'a ce qu'on occupe tous les CPU du système. C'est ce qu'empêche le GIL: les threads s'exécutent l'une après l'autre et la durée ne change pas trop.

- W

**UnCurieux** · 17/06/2019, 19h57

Envoyé par wiztricks

La documentation contient un minimum d'exemple pour vous permettre de démarrer. Après, vu tout ce qu'on peut faire avec, il faut chercher un peu sur Internet pour voir ce qui se rapproche de ce que vous voulez faire (et avoir des idées sur d'autres possibilités).

J'ai essayé évidemment cette doc, ainsi que plusieurs autres, en anglais également, trouvés sur Internet, mais je n'ai pas réussi...

Envoyé par jmbain

J'ai continué à torturer un peu la bête pour voir.
En chargeant un peu plus la mule, et en calculant le temps passé, j'obtiens 9 secondes de traitement.
Si je mets thread_1.join() avant thread_2.start(), j'obtiens 6 secondes. C'est plus rapide si j'exécute les deux l'une après l'autre. Marrant non ?
J'explique ça en disant que le temps passé à équilibrer les threads est coûteux en cpu.
Moralité : les threads ne sont pas faites pour rendre les traitements plus rapides, mais pour simuler un traitement parallèle. Ceci est très pratique quand on utilise un GUI comme QT4, avec des traitement qui prennent du temps et que l'on veut exécuter en arrière-plan. Un peu trapu à programmer, mais ça, c'est autre chose...

Très intéressant, je vois donc que thread() n'est pas la méthode qu'il me faut, il faut vraiment que j'utilise multiprocessing

**jmbain** · 17/06/2019, 19h23

Envoyé par UnCurieux

Ici je crois qu'il devrait faire tourner for de 1 à 500 et de 500 à 1000 en même temps, mais ce n'est pas ce qui se passe : on dirait qu'il calcule d'abord thread_1 puis thread_2 !

Hello,
Est-on vraiment certain que print() est une bonne solution pour tester ce genre de choses ?
Pour s'en assurer, j'ajouterais un affichage de datetime.datetime.now() à chaque affichage.

J'ai fait le test en modifiant ton programme pour afficher à chaque itération. Ce que j'obtiens figure ci-après.
On voit que les threads s'exécutent "plus ou moins" en même temps, ce qui est le but recherché. L'affichage du résultat final n'est pas suffisant pour juger, d'autant que thread_1 et thread_2 n'ont pas du tout la même charge.

...
print(datetime.datetime.now(),i)
...

donne :
...
2019-06-17 19:34:34.597912 256
2019-06-17 19:34:34.598315 600
2019-06-17 19:34:34.598780 601
2019-06-17 19:34:34.598860 602
2019-06-17 19:34:34.598956 603
2019-06-17 19:34:34.599121 604
2019-06-17 19:34:34.599177 605
2019-06-17 19:34:34.599304 606
2019-06-17 19:34:34.599731 607
2019-06-17 19:34:34.599797 608
2019-06-17 19:34:34.599863 609
2019-06-17 19:34:34.599955 610
2019-06-17 19:34:34.600030 611
2019-06-17 19:34:34.600574 612
2019-06-17 19:34:34.601010 613
2019-06-17 19:34:34.601307 614
2019-06-17 19:34:34.601382 615
2019-06-17 19:34:34.601444 616
2019-06-17 19:34:34.601879 617
2019-06-17 19:34:34.602007 618
2019-06-17 19:34:34.602443 619
2019-06-17 19:34:34.602511 620
2019-06-17 19:34:34.602578 621
2019-06-17 19:34:34.602882 622
2019-06-17 19:34:34.602997 623
2019-06-17 19:34:34.603058 624
2019-06-17 19:34:34.603109 625
2019-06-17 19:34:34.603464 257
2019-06-17 19:34:34.603514 258
2019-06-17 19:34:34.603556 259
2019-06-17 19:34:34.603592 260
2019-06-17 19:34:34.603635 261
2019-06-17 19:34:34.603724 262
2019-06-17 19:34:34.603841 263
2019-06-17 19:34:34.603876 264
2019-06-17 19:34:34.603927 265
2019-06-17 19:34:34.603962 266
2019-06-17 19:34:34.604031 267
2019-06-17 19:34:34.604090 268
2019-06-17 19:34:34.604211 269
2019-06-17 19:34:34.604243 270
2019-06-17 19:34:34.604386 271
2019-06-17 19:34:34.604423 272
2019-06-17 19:34:34.604458 273
2019-06-17 19:34:34.604551 274
2019-06-17 19:34:34.604584 275
2019-06-17 19:34:34.604623 276
2019-06-17 19:34:34.604746 277
2019-06-17 19:34:34.604839 278
2019-06-17 19:34:34.604879 279
2019-06-17 19:34:34.604913 280
2019-06-17 19:34:34.605038 281
2019-06-17 19:34:34.605086 282
2019-06-17 19:34:34.605212 283
2019-06-17 19:34:34.605272 284
2019-06-17 19:34:34.605307 285
2019-06-17 19:34:34.605343 286
2019-06-17 19:34:34.605387 287
2019-06-17 19:34:34.605419 288
2019-06-17 19:34:34.605449 289
2019-06-17 19:34:34.605488 290
2019-06-17 19:34:34.605559 291
2019-06-17 19:34:34.605620 292
2019-06-17 19:34:34.605750 293
2019-06-17 19:34:34.605782 294
2019-06-17 19:34:34.605835 295
2019-06-17 19:34:34.605879 296
2019-06-17 19:34:34.605913 297
2019-06-17 19:34:34.606011 298
2019-06-17 19:34:34.606045 299
2019-06-17 19:34:34.606077 300
2019-06-17 19:34:34.606123 301
2019-06-17 19:34:34.606228 302
2019-06-17 19:34:34.606301 303
2019-06-17 19:34:34.606337 304
2019-06-17 19:34:34.606393 305
2019-06-17 19:34:34.606430 306
2019-06-17 19:34:34.606565 307
2019-06-17 19:34:34.606600 308
2019-06-17 19:34:34.606674 309
2019-06-17 19:34:34.606715 310
2019-06-17 19:34:34.606852 311
2019-06-17 19:34:34.606888 312
2019-06-17 19:34:34.607025 313
2019-06-17 19:34:34.607127 314
2019-06-17 19:34:34.607160 315
2019-06-17 19:34:34.607223 316
2019-06-17 19:34:34.607362 317
2019-06-17 19:34:34.607413 318
2019-06-17 19:34:34.607451 319
2019-06-17 19:34:34.607485 320
2019-06-17 19:34:34.607562 321
2019-06-17 19:34:34.607598 322
2019-06-17 19:34:34.607630 323
2019-06-17 19:34:34.607662 324
2019-06-17 19:34:34.607696 325
2019-06-17 19:34:34.607801 326
2019-06-17 19:34:34.607879 327
2019-06-17 19:34:34.607924 328
2019-06-17 19:34:34.607971 329
2019-06-17 19:34:34.608005 330
2019-06-17 19:34:34.608151 331
2019-06-17 19:34:34.608217 332
2019-06-17 19:34:34.608260 333
2019-06-17 19:34:34.608383 334
2019-06-17 19:34:34.608622 626
2019-06-17 19:34:34.608663 627
2019-06-17 19:34:34.608765 628
2019-06-17 19:34:34.608806 629
2019-06-17 19:34:34.608839 630
2019-06-17 19:34:34.609102 631
2019-06-17 19:34:34.609166 632
2019-06-17 19:34:34.609291 633
2019-06-17 19:34:34.609474 634
2019-06-17 19:34:34.609560 635
2019-06-17 19:34:34.609611 636
2019-06-17 19:34:34.609645 637
2019-06-17 19:34:34.609684 638
2019-06-17 19:34:34.609743 639
2019-06-17 19:34:34.609776 640
2019-06-17 19:34:34.610048 641
2019-06-17 19:34:34.610125 642
2019-06-17 19:34:34.610398 643
2019-06-17 19:34:34.610438 644
etc

**UnCurieux** · 17/06/2019, 19h27

Eh bien print() n'affiche ici qu'un résultat pour chaque thread, donc ce n'est pas gênant.

**jmbain** · 17/06/2019, 19h56

J'ai continué à torturer un peu la bête pour voir.
En chargeant un peu plus la mule, et en calculant le temps passé, j'obtiens 9 secondes de traitement.
Si je mets thread_1.join() avant thread_2.start(), j'obtiens 6 secondes. C'est plus rapide si j'exécute les deux l'une après l'autre. Marrant non ?
J'explique ça en disant que le temps passé à équilibrer les threads est coûteux en cpu.
Moralité : les threads ne sont pas faites pour rendre les traitements plus rapides, mais pour simuler un traitement parallèle. Ceci est très pratique quand on utilise un GUI comme QT4, avec des traitement qui prennent du temps et que l'on veut exécuter en arrière-plan. Un peu trapu à programmer, mais ça, c'est autre chose...

**wiztricks** · 17/06/2019, 21h17

Envoyé par jmbain

les threads ne sont pas faites pour rendre les traitements plus rapides, mais pour simuler un traitement parallèle.

Pour autant qu'on précise "les threads utilisées avec CPython..."

Envoyé par UnCurieux

J'ai essayé évidemment cette doc, ainsi que plusieurs autres, en anglais également, trouvés sur Internet, mais je n'ai pas réussi...

C'est bien dommage mais si vous ne montrez pas ce que vous avez essayé de faire, il sera difficile de vous aider.

- W

**VinsS** · 18/06/2019, 07h50

Salut,

Ton .join() fait toute la différence. Ce .join() n'est utile que lorsque il est impératif d'avoir le résultat de chaque thread dans l'ordre ou lors de l'utilisation d'une lib C non thread-safe.

Un exemple pour montrer cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
from threading import Thread
import time
 
def process(idx):
    print("Thread %s start" % idx)
    for i in range(10000):
        x = i ** 3
    print("Thread %s stage 2" % idx)
    for i in range(10000):
        x = i ** 3
    print("Thread %s end" % idx)
 
begin = time.clock()
for j in range(10):
    t = Thread(target=process, args=(j,))
    t.start()
    #t.join()
 
print("Done at: %s sec." % (time.clock() - begin))

Sans le t.join() on obtient ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
Thread 0 start
Thread 1 start
Thread 0 stage 2
Thread 2 start
Thread 1 stage 2
Thread 2 stage 2
Thread 3 start
Thread 4 start
Thread 2 end
Thread 0 end
Thread 3 stage 2
Thread 5 start
Thread 1 end
Thread 4 stage 2
Thread 6 start
Thread 3 end
Thread 4 end
Thread 5 stage 2
Thread 8 start
Done at: 0.08717799999999999 sec.
Thread 6 stage 2
Thread 7 start
Thread 5 end
Thread 9 start
Thread 8 stage 2
Thread 7 stage 2
Thread 9 stage 2
Thread 6 end
Thread 9 end
Thread 7 end
Thread 8 end

On remarque que c'est le boxon complet dans l'ordre d'exécution des threads. En fait, ils se bousculent tous au portillon se jouant des coudes pour passer l'un avant l'autre.

Il suffit de dé-commenter le t.joint() pour retrouver une exécution parfaitement ordonnée.

Attention, le temps calculé n'est probablement pas significatif puisque dans le premier cas il est calculé avant le fin du travail.

**wiztricks** · 18/06/2019, 08h30

Envoyé par VinsS

Ton .join() fait toute la différence. Ce .join() n'est utile que lorsque il est impératif d'avoir le résultat de chaque thread dans l'ordre ou lors de l'utilisation d'une lib C non thread-safe.

.join est utile pour avoir le temps total de l'exécution de l'ensemble des threads (puisqu'on compare parallélisé à séquentiel). Si on attend qu'un thread se termine avant d'en lancer un autre, autant ne pas utiliser de threads!
Ca s'utilise comme çà:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from threading import Thread
import time
 
messages = []
 
def store(m):
    messages.append(m)
store = print
 
def process(idx):
    store("Thread %s start" % idx)
    for i in range(10000):
        x = i ** 3
    store("Thread %s stage 2" % idx)
    for i in range(10000):
        x = i ** 3
    store("Thread %s end" % idx)
 
begin = time.clock()
L = []
for j in range(5):
    t = Thread(target=process, args=(j,))
    t.start()
    L.append(t)
 
for t in L:
    t.join()
 
print("Done at: %s sec." % (time.clock() - begin))
print('\n'.join(messages))

Envoyé par VinsS

On remarque que c'est le boxon complet dans l'ordre d'exécution des threads. En fait, ils se bousculent tous au portillon se jouant des coudes pour passer l'un avant l'autre.

Si on met en commentaire store = print, çà sort:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Done at: 0.2077577061600107 sec.
Thread 0 start
Thread 1 start
Thread 0 stage 2
Thread 1 stage 2
Thread 2 start
Thread 1 end
Thread 0 end
Thread 2 stage 2
Thread 2 end
Thread 3 start
Thread 3 stage 2
Thread 4 start
Thread 4 stage 2
Thread 3 end
Thread 4 end

C'est un peu moins multiplexé qu'avec "print" direct:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Thread 0 start
Thread 1 start
Thread 0 stage 2
Thread 2 start
Thread 3 start
Thread 0 end
Thread 2 stage 2
Thread 4 start
Thread 3 stage 2
Thread 2 end
Thread 4 stage 2
Thread 3 end
Thread 1 stage 2
Thread 4 end
Thread 1 end
Done at: 0.2293455156988063 sec.

simplement à cause de l'IO provoquée par le "print".

Et si on prend cet exemple pour voir la différence entre Thread et multiprocessing:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from threading import Thread
#from multiprocessing import Process as Thread
import time
 
def process(idx):
    print("Thread %s start" % idx)
    for i in range(10000):
        x = i ** 3
    print("Thread %s stage 2" % idx)
    for i in range(10000):
        x = i ** 3
    print("Thread %s end" % idx)
 
if __name__ == '__main__':
    begin = time.clock()
 
    for j in range(5):
        t = Thread(target=process, args=(j,))
        t.start()
        L.append(t)
 
    for t in L:
        t.join()
 
    print("Done at: %s sec." % (time.clock() - begin))

Les threads tournent en 0.26 sec ce qui est à peine un peu meilleur que si on ne parallélisait pas du tout... et avec le multiprocessing, çà donne on obtient: 0.65: un peu plus de 2 fois plus.
Ça veut juste dire que paralléliser à un coût et que l'activité qu'on parallélise doit prendre un temps bien supérieur à ce coût là pour que çà apporte quelque chose (à la durée mesurée).

- W

**UnCurieux** · 24/06/2019, 22h15

Envoyé par wiztricks

C'est bien dommage mais si vous ne montrez pas ce que vous avez essayé de faire, il sera difficile de vous aider.

Je regardais les exemples en essayant de les comprendre à l'aide des explications, et quand je commençais un peu à comprendre je copiais le code puis essayais de le remplacer par celui que je souhaitais exécuter. Cela n'a pas fonctionné...
Avec les nouveaux exemples qui m'ont gentiment été donnés par les membres plus haut, je vais réessayer, de plus j'ai continué mes recherches sur multiprocessing principalement donc je devrais y arriver cette fois.
Merci encore, c'est bien plus clair ainsi

Utiliser le module threading : fonctionnement étrange

Python

Vue hybride

Discussions similaires

Partager

Partager