Comment obtenir une vitesse plus rapide lors de l'utilisation de multi-threading en python

Dans de nombreux cas, le python de thread n'est pas d'améliorer la vitesse d'exécution très bien... parfois, il fait qu'empirer les choses. Pour plus d'informations, voir David Beazley de PyCon2010 présentation Mondiale de l'Interprète de Verrouillage /Pycon2010 GIL dias. Cette présentation est très instructif, je le recommande fortement à toute personne qui envisage de filetage...

Même si David Beazley parler explique que le trafic réseau qui améliore la planification de Python module threading, vous devez utiliser le module multiprocessing. J'ai inclus cette option dans votre code (voir en bas de ma réponse).

L'exécution de ce sur une de mes anciennes machines (Python 2.6.6):

current_post.mode == "Process"  (multiprocessing)  --> 0.2609 seconds
current_post.mode == "Multiple" (threading)        --> 0.3947 seconds
current_post.mode == "Simple"   (serial execution) --> 1.650 seconds

Je suis d'accord avec TokenMacGuy commentaire et les chiffres ci-dessus comprennent le déplacement des .join() à une autre boucle. Comme vous pouvez le voir, python multitraitement est nettement plus rapide que le filetage.

from multiprocessing import Process
import threading
import time
import urllib
import urllib2
class Post:
def __init__(self, website, data, mode):
self.website = website
self.data = data
#mode is either:
#   "Simple"      (Simple POST)
#   "Multiple"    (Multi-thread POST)
#   "Process"     (Multiprocessing)
self.mode = mode
self.run_job()
def post(self):
#post data
req = urllib2.Request(self.website)
open_url = urllib2.urlopen(req, self.data)
if self.mode == "Multiple":
time.sleep(0.001)
#read HTMLData
HTMLData = open_url.read()
#print "OK"
def run_job(self):
"""This was refactored from the OP's code"""
origin_time = time.time()
if(self.mode == "Multiple"):
#multithreading POST
threads = list()
for i in range(0, 10):
thread = threading.Thread(target = self.post)
thread.start()
threads.append(thread)
for thread in threads:
thread.join()
#calculate the time interval
time_interval = time.time() - origin_time
print "mode - {0}: {1}".format(method, time_interval)
if(self.mode == "Process"):
#multiprocessing POST
processes = list()
for i in range(0, 10):
process = Process(target=self.post)
process.start()
processes.append(process)
for process in processes:
process.join()
#calculate the time interval
time_interval = time.time() - origin_time
print "mode - {0}: {1}".format(method, time_interval)
if(self.mode == "Simple"):
#simple POST
for i in range(0, 10):
self.post()
#calculate the time interval
time_interval = time.time() - origin_time
print "mode - {0}: {1}".format(method, time_interval)
return time_interval
if __name__ == "__main__":
for method in ["Process", "Multiple", "Simple"]:
Post("http://forum.xda-developers.com/login.php", 
"vb_login_username=test&vb_login_password&securitytoken=guest&do=login",
method
)

Gardez à l'esprit que le seul cas où le multi-threading peut "augmenter la vitesse" en Python, c'est quand vous avez opérations comme celui-ci qui sont fortement I/O bound. Sinon le multi-threading n'augmente pas de "vitesse" car il ne peut pas fonctionner sur plus d'un CPU (non, pas même si vous disposez de plusieurs cœurs, python ne fonctionne pas de cette façon). Vous devez utiliser le multi-threading lorsque vous souhaitez que deux choses à faire en même temps, pas quand vous avez besoin de deux choses pour être parallèle (c'est à dire deux processus en cours d'exécution séparément).

Maintenant, ce que vous êtes en train de faire ne sera pas réellement d'augmenter la vitesse de recherche DNS, mais il permettra aussi de multiples demandes à être tiré en attendant les résultats de certains autres, mais vous devez faire attention à la façon dont beaucoup vous faire ou vous faites juste le temps de réponse encore pire qu'ils ne le sont déjà.

Aussi s'il vous plaît arrêter d'utiliser urllib2, et l'utilisation des Demandes: http://docs.python-requests.org