Re: bug

Ah oui, bien vu ! Mais du coup je ne comprends pas pourquoi la méthode 2. va plus vite que la méthode 1. (sauf si le temps de sommeil est le même pour tous les nourrissons, là les deux méthodes vont à la même vitesse (?!))

Évidemment pour faire ce que je veux je pourrais créé un seul pool... mais j’aimerais bien comprendre ce qu’il y a de différent entre 1. et 2.

Sinon j’ai compris comment utiliser l’objet Queue, qui me permet de lancer plusieurs processus en parallèle et de récupérer leurs résultats au fur et à mesure :

#!/usr/bin/env python3
from multiprocessing import Process, Queue
from random import randint, sample
from time import sleep, time
import string
from pprint import pprint
from ctypes import c_wchar_p
def plop(q, i):
 val1 = randint(0,5)
 val2 = ''.join(sample(string.ascii_lowercase,randint(3,7)))
 sleep(val1)
 q.put((i, val1, val2))
items = range(0, 20)
queue = Queue()
for index in items:
 process = Process(target=plop, args=(queue, index))
 process.start()
for index in items:
 print(queue.qsize(), "\t", "\t".join(map(str, list(queue.get()))), flush=True)

Voici la sortie :

stef@medusa:~/Code/Test$ ./p2.py 
4 7 0 qfbliw
3 0 0 hno
2 13 0 pwd
1 12 0 zbo
0 3 1 dxrch
0 8 1 caig
0 11 1 prwcf
0 10 1 ftjbel
0 15 1 vprcg
0 1 2 crkpqzo
1 6 2 qntlr
0 9 2 lruh
0 4 3 tdbyip
0 2 3 inwleyo
0 14 3 pulrgd
0 19 3 ikuh
0 5 4 rkt
0 16 5 wnzx
1 17 5 atlnx
0 18 5 yiejnox

Le première colonne c’est la taille de la file (Queue), deuxième colonne l’index de l’item (qui correspond à l’ordre de lancement du process), en troisième colonne le temps pris par le process (temps de sleep()) et en quatrième colonne la valeur aléatoire générée par chaque process.

On peut voir que la taille de la file est importante au début... Voilà comment je le comprends : quand on fait le get() dans la deuxième boucle, on commence par le premier item, donc pendant qu’on attend ce premier process les suivants ont possiblement déjà terminé, venant s’enfiler dans queue.

On a les résultats « dans l’ordre logique », c’est à dire qu’on a les process qui prennent le plus de temps en dernier.

Avec cette dernière méthode le temps total ne dépasse pas le temps pris par le process qui dure le plus longtemps.

Par ailleurs j’ai également réussi à utiliser l’objet Manager, qui permet aussi de partager des variables, mais bon... un concept à la fois...

J’ai l’impression que pour un besoin donné il n’y a pas une seule bonne méthode et qu’en fait on a plutôt le choix, entre utiliser Pool, Queue, Manager, Process ou autre... j’ai encore du mal à bien voir quels sont les avantages et inconvénients de chacun.
```