python limiter nombre de processus

Bonjour, je voudrais limiter le nombre de processus de mon programme à 4. C’est a dire que si mon programme à plus de 4 processus actif il attend que les autres se termine avant d’en lancer d’autre

voici mon code simplifié, je voudrais que au lieu de crée 100 processus d’un coup, python se limite à 4 seulement (définie dans ma variable number_of_core)

 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

from multiprocessing import Process, Queue, Manager

def funct1(data):
    data.append(1)



if __name__ == '__main__':
    manager = Manager()
    data = manager.list()

    procs=[]
    number_of_core=4

    for i in range(0,100):
        p = Process(target=funct1, args=(data,))
        p.start()   
        procs.append(p)


    for process in procs :
        process.join()


    print(data)
    print(len(data))

dans mon cas l’ordre des éléments à ajouter dans ma liste "data" n’a pas d’importance je souhaite ajouter 100 éléments dans la liste, mais pas plus de 4 en même temps.

ici, c’est un exemple bateau mais dans mon vrai code, la fonction funct1 effectue des traitements plus lourds que je voudrais paralléliser, mais si python me crée 100 process d’un coup sa sature (pour rien), donc je voudrais le limiter au nombre de coeur de ma machine : 4 (je sais qu’il existe une fonction dans multiprocessing pour connaitre le nombre de cpu sur sa machine)

Salut,

Ce que tu cherches à faire est réalisable, mais il te faudra un fil dédié pour inspecter la liste des processus, et lancer le suivant quand un se termine.

Ça n’est pas exactement la manière dont tu décris la solution, mais je pense que la classe Pool du module multiprocessing serait plus pertinente pour résoudre ton problème.

pool d’apres ce que j’ai vue permet de lancer 4 fois une fonction :https://docs.python.org/2/library/multiprocessing.html

1
2

p = Pool(5)
    print(p.map(f, [1, 2, 3]))

mais je vois comment on peut limiter le nombre de process avec ?

bah tu auras au maximum 5 process en parallèle.

oui mais je fais comment pour exécuter mes 100 process en en exécutant que 4 en même temps maximum ?

Avec Pool, la logique est légèrement différente : tu lance 4 process, mais ils peuvent très bien traiter 100 jeux de données différents. Ainsi, chaque process va traiter un jeu de données après l’autres jusqu’a ce que toutes les données soient traitées.

1

print(p.map(f, range(100)))

je suis désolé mais je ne comprend pas… voila ce que j’ai fais :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

from multiprocessing import Manager, Pool

def funct1(data):
    data.append(1)



if __name__ == '__main__':
    manager = Manager()
    data = manager.list()

    procs=[]
    number_of_core=4

    for i in range(0,25):
        p = Pool(4)
        p.map(funct1, data)

    print(data)
    print(len(data))

ok je vois, merci.

mais mon exemple n’étais peut être pas représentatif, en faite à la place de range(0,25) il s’agit d’une liste de nombres qui peut varier (il peut y en avoir 100,1000,1,2,23…) maliste= [1,1.5,7,5,5.644,3,4] en l’occurrence, je souhaite au maximum traiter 4 élément en même temps, j’ai l’impression qu’il vas falloir faire du découpage de liste ?

Ah ok merci, j’ai enfin compris !

je me rend compte que pool a quand même des limites, résults ajoute des éléments dans une liste, peut on plutôt faire une extend ou bien utiliser un manager.list ? dans mon cas, la funct2 ressemble plutot à ceci :

1
2
3
4
5
6

def funct1(n):
    maliste=[]
    maliste.append(n**2)
    return maliste

`

Je comprend pas, ta fonction renvoi une liste que tu veux mettre à plat ?

Si oui tu peux faire ça facilement ensuite : result = [v for l in result for v in l] (par exemple).