💌 😓 👨‍⚖️ Pourquoi, quand et comment utiliser le multithreading et le multiprocessing en Python 🧙🏻 🔤 🏢

Salut, Khabrovsk. En ce moment, OTUS a ouvert un ensemble pour le cours de Machine Learning , à cet égard, nous avons traduit pour vous un «conte de fées» très intéressant. Aller.

Il était une fois, dans une galaxie lointaine, lointaine ... Un

sorcier sage et puissant vivait dans un petit village au milieu du désert. Et leur nom était Dumbledalf. Non seulement il était sage et puissant, mais il a également aidé des gens venus de pays lointains à demander l'aide d'un sorcier. Notre histoire a commencé lorsqu'un voyageur a apporté au sorcier un parchemin magique. Le voyageur ne savait pas ce qu'il y avait dans le parchemin, il savait seulement que si quelqu'un pouvait révéler tous les secrets du parchemin, alors c'était Dumbledalf.

Chapitre 1: Single-Thread, Single-Process

Si vous n'avez pas encore deviné, j'ai fait une analogie avec le processeur et ses fonctions. Notre assistant est un processeur, et un parchemin est une liste de liens qui mènent à la puissance et aux connaissances de Python pour le maîtriser.

La première pensée d'un sorcier qui a déchiffré la liste sans aucune difficulté a été d'envoyer son fidèle ami (Garrigorn? Je sais, je sais que cela semble horrible) à chacun des endroits décrits dans le parchemin afin de trouver et d'apporter ce qu'il pouvait y trouver.

In [1]:
import urllib.request
from concurrent.futures import ThreadPoolExecutor
In [2]:
urls = [
  'http://www.python.org',
  'https://docs.python.org/3/',
  'https://docs.python.org/3/whatsnew/3.7.html',
  'https://docs.python.org/3/tutorial/index.html',
  'https://docs.python.org/3/library/index.html',
  'https://docs.python.org/3/reference/index.html',
  'https://docs.python.org/3/using/index.html',
  'https://docs.python.org/3/howto/index.html',
  'https://docs.python.org/3/installing/index.html',
  'https://docs.python.org/3/distributing/index.html',
  'https://docs.python.org/3/extending/index.html',
  'https://docs.python.org/3/c-api/index.html',
  'https://docs.python.org/3/faq/index.html'
  ]
In [3]:
%%time

results = []
for url in urls:
    with urllib.request.urlopen(url) as src:
        results.append(src)

CPU times: user 135 ms, sys: 283 µs, total: 135 ms
Wall time: 12.3 s
In [ ]:

Comme vous pouvez le voir, nous parcourons simplement les URL une par une en utilisant la boucle for et lisons la réponse. Grâce à %% time et à la magie d' IPython , nous pouvons voir que cela a pris environ 12 secondes avec mon triste Internet.

Chapitre 2: Multithreading

Ce n'était pas sans raison que le sorcier était célèbre pour sa sagesse; il a rapidement réussi à trouver un moyen beaucoup plus efficace. Au lieu d'envoyer une personne à chaque endroit dans l'ordre, pourquoi ne pas réunir une équipe d'associés fiables et les envoyer dans différentes parties du monde en même temps! L'assistant pourra unir toutes les connaissances qu'il apporte en même temps!

C'est vrai, au lieu d'afficher la liste dans une boucle en séquence, nous pouvons utiliser le multithreading pour accéder à plusieurs URL à la fois.

In [1]:
import urllib.request
from concurrent.futures import ThreadPoolExecutor
In [2]:
urls = [
  'http://www.python.org',
  'https://docs.python.org/3/',
  'https://docs.python.org/3/whatsnew/3.7.html',
  'https://docs.python.org/3/tutorial/index.html',
  'https://docs.python.org/3/library/index.html',
  'https://docs.python.org/3/reference/index.html',
  'https://docs.python.org/3/using/index.html',
  'https://docs.python.org/3/howto/index.html',
  'https://docs.python.org/3/installing/index.html',
  'https://docs.python.org/3/distributing/index.html',
  'https://docs.python.org/3/extending/index.html',
  'https://docs.python.org/3/c-api/index.html',
  'https://docs.python.org/3/faq/index.html'
  ]
In [4]:
%%time

with ThreadPoolExecutor(4) as executor:
    results = executor.map(urllib.request.urlopen, urls)

CPU times: user 122 ms, sys: 8.27 ms, total: 130 ms
Wall time: 3.83 s
In [5]:
%%time

with ThreadPoolExecutor(8) as executor:
    results = executor.map(urllib.request.urlopen, urls)

CPU times: user 122 ms, sys: 14.7 ms, total: 137 ms
Wall time: 1.79 s
In [6]:
%%time

with ThreadPoolExecutor(16) as executor:
    results = executor.map(urllib.request.urlopen, urls)

CPU times: user 143 ms, sys: 3.88 ms, total: 147 ms
Wall time: 1.32 s
In [ ]:

Bien mieux! Presque comme ... de la magie. L'utilisation de plusieurs threads peut accélérer considérablement de nombreuses tâches d'E / S. Dans mon cas, la plupart du temps passé à lire les URL est dû à la latence du réseau. Les programmes liés aux E / S passent la majeure partie de leur vie à attendre, vous l'aurez deviné, une entrée ou une sortie (tout comme un sorcier attend que ses amis se rendent à des endroits du défilement et reviennent). Cela peut être entré / sorti à partir du réseau, de la base de données, du fichier ou de l'utilisateur. Ces E / S prennent généralement beaucoup de temps, car la source peut avoir besoin d'effectuer un prétraitement avant de transférer les données vers les E / S. Par exemple, un processeur comptera beaucoup plus rapidement qu'une connexion réseau transmettra des données (à une vitesse d'environcomme Flash contre votre grand-mère).

Remarque : multithreadingpeut être très utile dans des tâches telles que le nettoyage de pages Web.

Chapitre 3: Multiprocessing

Les années ont passé, la renommée du bon sorcier a grandi, et avec elle a grandi l'envie d'un sorcier noir impartial (Sarumort? Ou peut-être Volandeman?). Armé d'une ruse incommensurable et poussé par l'envie, le sorcier noir jeta une terrible malédiction sur Dumbledalf. Lorsque la malédiction le rattrapa, Dumbledalf se rendit compte qu'il n'avait que quelques instants pour le repousser. Désespéré, il fouilla dans ses livres de sorts et trouva rapidement un contre-sort qui était censé fonctionner. Le seul problème était que l'assistant devait calculer la somme de tous les nombres premiers inférieurs à 1 000 000. Un sort étrange, bien sûr, mais ce que nous avons.

Le sorcier savait que calculer la valeur serait trivial s'il avait assez de temps, mais il n'avait pas ce luxe. Malgré le fait qu'il soit un grand sorcier, il est limité par son humanité et ne peut vérifier la simplicité qu'un seul numéro à la fois. S'il décidait de simplement additionner les nombres premiers les uns après les autres, cela prendrait trop de temps. Lorsqu'il ne restait que quelques secondes avant d'appliquer le contre-sort , il se souvint soudain du sort de multi- traitement , qu'il avait appris du parchemin magique il y a de nombreuses années. Ce sort lui permettra de se copier afin de répartir les nombres entre ses copies et d'en vérifier plusieurs en même temps. Et à la fin, tout ce qu'il doit faire, c'est simplement additionner les chiffres que lui et ses copies découvriront.

In [1]:
from multiprocessing import Pool
In [2]:
def if_prime(x):
    if x <= 1:
        return 0
    elif x <= 3:
        return x
    elif x % 2 == 0 or x % 3 == 0:
        return 0
    i = 5
    while i**2 <= x:
        if x % i == 0 or x % (i + 2) == 0:
            return 0
        i += 6
    return x
In [17]:
%%time

answer = 0

for i in range(1000000):
    answer += if_prime(i)

CPU times: user 3.48 s, sys: 0 ns, total: 3.48 s
Wall time: 3.48 s
In [18]:
%%time

if __name__ == '__main__':
    with Pool(2) as p:
        answer = sum(p.map(if_prime, list(range(1000000))))

CPU times: user 114 ms, sys: 4.07 ms, total: 118 ms
Wall time: 1.91 s
In [19]:
%%time

if __name__ == '__main__':
    with Pool(4) as p:
        answer = sum(p.map(if_prime, list(range(1000000))))

CPU times: user 99.5 ms, sys: 30.5 ms, total: 130 ms
Wall time: 1.12 s
In [20]:
%%timeit

if __name__ == '__main__':
    with Pool(8) as p:
        answer = sum(p.map(if_prime, list(range(1000000))))

729 ms ± 3.02 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
In [21]:
%%timeit

if __name__ == '__main__':
    with Pool(16) as p:
        answer = sum(p.map(if_prime, list(range(1000000))))

512 ms ± 39.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
In [22]:
%%timeit

if __name__ == '__main__':
    with Pool(32) as p:
        answer = sum(p.map(if_prime, list(range(1000000))))

518 ms ± 13.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
In [23]:
%%timeit

if __name__ == '__main__':
    with Pool(64) as p:
        answer = sum(p.map(if_prime, list(range(1000000))))

621 ms ± 10.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
In [ ]:

Les processeurs modernes ont plus d'un cœur, nous pouvons donc accélérer les tâches en utilisant le multiprocessing du module de traitement multiprocess . Les tâches associées au processeur sont des programmes qui effectuent la plupart du temps des calculs sur le processeur (calculs mathématiques triviaux, traitement d'image, etc.). Si les calculs peuvent être effectués indépendamment les uns des autres, nous avons la possibilité de les diviser entre les cœurs de processeur disponibles, obtenant ainsi une augmentation significative de la vitesse de traitement.

Tout ce que tu dois faire est:

Déterminez la fonction à appliquer.
Préparer une liste d'éléments auxquels la fonction sera appliquée;
multiprocessing.Pool. , Pool(), . with , .
Pool map. map , , .

Remarque : Une fonction peut être définie pour effectuer n'importe quelle tâche pouvant être effectuée en parallèle. Par exemple, une fonction peut contenir du code pour écrire le résultat d'un calcul dans un fichier.

Alors, pourquoi devons-nous séparermultiprocessingetmultithreading? Si vous avez déjà essayé d'améliorer les performances d'une tâche sur le processeur en utilisant le multithreading, le résultat est exactement le contraire. C'est tout simplement terrible! Voyons comment cela s'est produit.

Tout comme un assistant est limité par sa nature humaine et ne peut calculer qu'un seul nombre par unité de temps, Python est livré avec une chose appelée Global Interpreter Lock (GIL) . Python est heureux de vous permettre de générer autant de threads que vous le souhaitez, mais GILgarantit qu'un seul de ces threads s'exécutera à un moment donné.

Pour une tâche liée aux E / S, cette situation est tout à fait normale. Un thread envoie une demande à une URL et attend une réponse, alors ce thread peut être remplacé par un autre, qui enverra une autre demande à une URL différente. Étant donné que le thread n'a rien à faire jusqu'à ce qu'il reçoive une réponse, cela ne fait aucune différence qu'à un moment donné, un seul thread est en cours d'exécution.

Pour les tâches effectuées sur le processeur, avoir plusieurs threads est presque aussi inutile que les mamelons dans l'armure. Étant donné qu'un seul thread peut être exécuté par unité de temps, même si vous en générez plusieurs, chacun se verra attribuer un numéro pour vérifier la simplicité, le processeur fonctionnera toujours avec un seul thread. En fait, ces chiffres seront toujours vérifiés un par un. Et la surcharge de travail avec plusieurs threads contribuera à réduire les performances, ce que vous pouvez simplement observer lorsqu'il est utilisé multithreadingdans des tâches effectuées sur le processeur.

Pour contourner cette «restriction», nous utilisons le modulemultiprocessing. Au lieu d'utiliser des threads, le multitraitement utilise, comme vous le dites ... plusieurs processus. Chaque processus a son propre interprète et son propre espace mémoire, donc le GIL ne vous limitera pas. En fait, chaque processus utilisera son propre cœur de processeur et fonctionnera avec son propre numéro unique, et cela sera effectué simultanément avec le travail d'autres processus. Comme c'est gentil de leur part!

Vous remarquerez peut-être que la charge du processeur sera plus élevée lorsque vous l'utiliserez multiprocessingpar rapport à une boucle for régulière ou même multithreading. Cela se produit car votre programme utilise non pas un cœur, mais plusieurs. Et c'est bien!

rappelez-vous, quemultiprocessingIl a ses propres frais généraux de gestion de plusieurs processus, ce qui est généralement plus grave que le coût du multithreading. (Le multitraitement génère des interprètes séparés et attribue sa propre zone de mémoire à chaque processus, alors oui!) C'est-à-dire, en règle générale, il est préférable d'utiliser une version allégée du multithreading lorsque vous souhaitez sortir de cette manière (rappelez-vous des tâches liées aux E / S). Mais lorsque le calcul sur le processeur devient un goulot d'étranglement, l'heure du module arrive multiprocessing. Mais souvenez-vous qu'avec une grande puissance, il y a une grande responsabilité.

Si vous générez plus de processus que votre processeur ne peut en traiter par unité de temps, vous remarquerez que les performances commenceront à décliner. Cela se produit car le système d'exploitation a besoin de faire plus de travail en mélangeant les processus entre les cœurs de processeur, car il y a plus de processus. En réalité, tout peut être encore plus compliqué que je ne vous l'ai dit aujourd'hui, mais j'ai véhiculé l'idée principale. Par exemple, sur mon système, les performances chutent lorsque le nombre de processus est de 16. C'est parce qu'il n'y a que 16 cœurs logiques dans mon processeur.

Chapitre 4: Conclusion

Dans les tâches liées aux E / S, cela multithreadingpeut améliorer les performances.
Dans les tâches liées aux E / S, multiprocessingcela peut également augmenter la productivité, mais les coûts sont généralement plus élevés que lors de l'utilisation multithreading.
L'existence de Python GIL nous montre clairement qu'à tout moment dans un programme, un seul thread peut s'exécuter.
Dans les tâches liées au processeur, l'utilisation multithreadingpeut réduire les performances.
Dans les tâches liées au processeur, l'utilisation multiprocessingpeut améliorer les performances.
Les sorciers sont géniaux!

C'est là que nous terminerons notre introduction à multithreadinget multiprocessingen Python aujourd'hui . Maintenant, allez gagner!

"Modélisation de COVID-19 à l'aide d'une analyse graphique et d'une analyse des données ouvertes." Leçon gratuite.

Pourquoi, quand et comment utiliser le multithreading et le multiprocessing en Python

Chapitre 1: Single-Thread, Single-Process

Chapitre 2: Multithreading

Chapitre 3: Multiprocessing

Chapitre 4: Conclusion

More articles: