Le multi-traitement ou le multi-threading est-il plus rapide en python ?

L'éditeur suivant vous proposera un article sur qui est le plus rapide entre python multi-processus et multi-thread (explication détaillée). L'éditeur pense que c'est plutôt bien, alors je vais le partager avec vous maintenant et le donner comme référence. Venez jeter un oeil avec l'éditeur

python3.6

Threading et multitraitement

Quad core + Samsung 250G-850-SSD

Utilisé depuis Programmation multi-processus et multi-thread, je ne comprends toujours pas laquelle est la plus rapide. De nombreuses personnes sur Internet disent que le multi-processus Python est plus rapide grâce au GIL (Global Interpreter Lock). Mais lorsque j'écrivais le code, le temps de test était plus rapide avec le multi-threading, alors que se passe-t-il ? Récemment, j'ai refait un travail de segmentation de mots. Le code original est trop lent et je souhaite l'accélérer, explorons donc les méthodes efficaces (il y a des codes et des rendus à la fin de l'article)

Voici le résultat du programme. Diagramme pour illustrer quel thread ou processus est le plus rapide

Quelques définitions.

Le parallélisme signifie que deux événements ou plus se produisent en même temps. La simultanéité signifie que deux événements ou plus se produisent dans le même intervalle de temps

Le thread est la plus petite unité que le système d'exploitation peut effectuer dans la planification des calculs. Il est inclus dans le processus et constitue la véritable unité opérationnelle du processus. Une instance d'exécution d'un programme est un processus.

Processus d'implémentation

Le multi-threading en python doit évidemment obtenir le GIL, exécuter le code, et enfin libérer le GIL. Donc, à cause de GIL, vous ne pouvez pas l'obtenir en utilisant plusieurs threads. En fait, il s'agit d'une implémentation simultanée, c'est-à-dire que plusieurs événements se produisent au même intervalle de temps.

Mais le processus a un GIL indépendant, il peut donc être mis en œuvre en parallèle. Par conséquent, pour les processeurs multicœurs, l’utilisation théorique de plusieurs processus peut utiliser les ressources plus efficacement.

Problèmes réels

Dans les tutoriels en ligne, le multithreading python est souvent visible. Par exemple, des didacticiels sur les robots d'exploration Web et des didacticiels sur l'analyse des ports.

Prenons l'exemple de l'analyse de port. Vous pouvez utiliser le multi-processus pour implémenter le script suivant, et vous constaterez que le multi-processus python est plus rapide. N’est-ce donc pas contraire à notre analyse ?

import sys,threading
from socket import *

host = "127.0.0.1" if len(sys.argv)==1 else sys.argv[1]
portList = [i for i in range(1,1000)]
scanList = []
lock = threading.Lock()
print('Please waiting... From ',host)


def scanPort(port):
  try:
    tcp = socket(AF_INET,SOCK_STREAM)
    tcp.connect((host,port))
  except:
    pass
  else:
    if lock.acquire():
      print('[+]port',port,'open')
      lock.release()
  finally:
    tcp.close()

for p in portList:
  t = threading.Thread(target=scanPort,args=(p,))
  scanList.append(t)
for i in range(len(portList)):
  scanList[i].start()
for i in range(len(portList)):
  scanList[i].join()

Qui est le plus rapide ?

En raison du problème des verrous Python, les threads en compétition pour les verrous et les changements de thread consommeront des ressources. Alors, faisons une supposition audacieuse :

Dans les tâches gourmandes en CPU, le multitraitement est plus rapide ou donne de meilleurs résultats ; tandis que dans les tâches gourmandes en E/S, le multithreading peut améliorer efficacement l'efficacité.

Regardez le code suivant :

import time
import threading
import multiprocessing

max_process = 4
max_thread = max_process

def fun(n,n2):
  #cpu密集型
  for i in range(0,n):
    for j in range(0,(int)(n*n*n*n2)):
      t = i*j

def thread_main(n2):
  thread_list = []
  for i in range(0,max_thread):
    t = threading.Thread(target=fun,args=(50,n2))
    thread_list.append(t)

  start = time.time()
  print(' [+] much thread start')
  for i in thread_list:
    i.start()
  for i in thread_list:
    i.join()
  print(' [-] much thread use ',time.time()-start,'s')

def process_main(n2):
  p = multiprocessing.Pool(max_process)
  for i in range(0,max_process):
    p.apply_async(func = fun,args=(50,n2))
  start = time.time()
  print(' [+] much process start')
  p.close()#关闭进程池
  p.join()#等待所有子进程完毕
  print(' [-] much process use ',time.time()-start,'s')

if name=='main':
  print("[++]When n=50,n2=0.1:")
  thread_main(0.1)
  process_main(0.1)
  print("[++]When n=50,n2=1:")
  thread_main(1)
  process_main(1)
  print("[++]When n=50,n2=10:")
  thread_main(10)
  process_main(10)

Les résultats sont les suivants :

Comme vous peut voir, lorsque l'utilisation du processeur devient de plus en plus élevée (plus il y a de cycles de code), l'écart devient de plus en plus large. Vérifiez notre conjecture

CPU et IO intensifs

1. Code gourmand en CPU (divers traitements de boucles, comptage, etc.)

2. Code gourmand en IO (traitement de fichiers, robot d'exploration Web, etc.)

Méthode de jugement :

1 . Regardez directement l'utilisation du processeur, la vitesse de lecture et d'écriture des E/S du disque dur

2. Plus de calculs->CPU ; plus de temps d'attente (comme les robots d'exploration Web)->E/S

3. Veuillez vous rendre sur Baidu

【Recommandations associées】

1. Exemples de multi-processus et multi-threading en Python (1)

2. Recommandé d'utiliser le multi-processus au lieu du multi-threading en Python ? Partagez les raisons pour lesquelles vous recommandez l'utilisation du multi-processus

3 Exemples de multi-processus et de multi-threading en Python (2) Méthodes de programmation

. 4. À propos de Python Introduction détaillée aux processus, aux threads et aux coroutines

5 Pool de threads/pool de processus de programmation simultanée Python

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!