Ein umfassendes Verständnis von Multithreading in Python. Eine Pflichtlektüre für Neulinge

Beispiel 1
Wir werden fünf verschiedene URLs anfordern:
Single-Threaded

import time
import urllib2
   
defget_responses():
  urls=[
    ‘http://www.baidu.com',
    ‘http://www.amazon.com',
    ‘http://www.ebay.com',
    ‘http://www.alibaba.com',
    ‘http://www.jb51.net'
  ]
  start=time.time()
  forurlinurls:
    printurl
    resp=urllib2.urlopen(url)
    printresp.getcode()
  print”Elapsed time: %s”%(time.time()-start)
   
get_responses()

Die Ausgabe ist:
http://www .baidu .com200
http://www.amazon.com200
http://www.ebay.com200
http://www.alibaba.com200
http://www.jb51 .net200
Abgelaufen Zeit: 3.0814409256

Erklärung:
URLs werden der Reihe nach angefordert
Solange die CPU keine Antwort von einer URL erhält, fordert sie nicht die nächste URL an
Netzwerkanfragen werden lange dauern, Die CPU war also im Leerlauf und wartete auf die Rückkehr der Netzwerkanforderung.
Multithreading

import urllib2
import time
from threading import Thread
   
classGetUrlThread(Thread):
  def__init__(self, url):
    self.url=url
    super(GetUrlThread,self).__init__()
   
  defrun(self):
    resp=urllib2.urlopen(self.url)
    printself.url, resp.getcode()
   
defget_responses():
  urls=[
    ‘http://www.baidu.com',
    ‘http://www.amazon.com',
    ‘http://www.ebay.com',
    ‘http://www.alibaba.com',
    ‘http://www.jb51.net'
  ]
  start=time.time()
  threads=[]
  forurlinurls:
    t=GetUrlThread(url)
    threads.append(t)
    t.start()
  fortinthreads:
    t.join()
  print”Elapsed time: %s”%(time.time()-start)
   
get_responses()

Ausgabe:
http://www.jb51.net200
http://www.baidu.com200
http ://www.amazon.com200
http://www.alibaba.com200
http://www.ebay.com200
Abgelaufen Zeit: 0,689890861511

Erklärung:

Wir sind uns der Verbesserung der Ausführungszeit des Programms bewusst
Wir haben ein Multithread-Programm geschrieben, um die Wartezeit der CPU zu verkürzen für einen Thread Wenn die Netzwerkanforderung zurückkehrt, kann die CPU zu anderen Threads wechseln, um Netzwerkanforderungen in anderen Threads auszuführen.
Wir erwarten, dass ein Thread eine URL verarbeitet, daher übergeben wir beim Instanziieren der Thread-Klasse eine URL.
Thread-Ausführung bedeutet, dass die run()-Methode in der Klasse ausgeführt wird.
Auf jeden Fall möchten wir, dass jeder Thread run() ausführt.
Erstellen Sie für jede URL einen Thread und rufen Sie die start()-Methode auf, die die CPU anweist, die run()-Methode im Thread auszuführen.
Wir hoffen, die aufgewendete Zeit berechnen zu können, wenn die Ausführung aller Threads abgeschlossen ist, und rufen daher die Methode „join()“ auf.
join() kann den Hauptthread benachrichtigen, auf das Ende dieses Threads zu warten, bevor die nächste Anweisung ausgeführt wird.
Wir rufen die Methode „join()“ für jeden Thread auf, sodass wir die Laufzeit berechnen, nachdem alle Threads die Ausführung abgeschlossen haben.

Über Threads:

Die CPU führt die run()-Methode möglicherweise nicht sofort nach dem Aufruf von start() aus.
Sie können die Ausführungsreihenfolge von run() zwischen verschiedenen Threads nicht bestimmen.
Für einen einzelnen Thread wird garantiert, dass die Anweisungen in der run()-Methode der Reihe nach ausgeführt werden.
Das liegt daran, dass zuerst die URL im Thread abgefragt wird und dann das zurückgegebene Ergebnis ausgedruckt wird.

Beispiel 2

Wir werden ein Programm verwenden, um den Ressourcenwettbewerb zwischen Multithreads zu demonstrieren und dieses Problem zu beheben.

from threading import Thread
   
#define a global variable
some_var=0
   
classIncrementThread(Thread):
  defrun(self):
    #we want to read a global variable
    #and then increment it
    globalsome_var
    read_value=some_var
    print”some_var in %s is %d”%(self.name, read_value)
    some_var=read_value+1
    print”some_var in %s after increment is %d”%(self.name, some_var)
   
defuse_increment_thread():
  threads=[]
  foriinrange(50):
    t=IncrementThread()
    threads.append(t)
    t.start()
  fortinthreads:
    t.join()
  print”After 50 modifications, some_var should have become 50″
  print”After 50 modifications, some_var is %d”%(some_var,)
   
use_increment_thread()

Führen Sie dieses Programm mehrmals aus und Sie werden eine Vielzahl unterschiedlicher Ergebnisse sehen.
Erklärung:
Es gibt eine globale Variable und alle Threads möchten sie ändern.
Alle Threads sollten diese globale Variable hinzufügen 1 .
Bei 50 Threads sollte der Endwert 50 werden, was aber nicht der Fall ist.
Warum hat es nicht 50 erreicht?
Wenn some_var 15 ist, liest Thread t1 some_var. Zu diesem Zeitpunkt übergibt die CPU die Kontrolle an einen anderen Thread t2.
Die vom t2-Thread gelesene some_var ist ebenfalls 15
Sowohl t1 als auch t2 erhöhen some_var auf 16
Was wir damals erwartet hatten, war t1 t2 zwei Threads machen some_var + Aus 2 wird 17
Hier herrscht Konkurrenz um Ressourcen.
Die gleiche Situation kann auch in anderen Threads auftreten, sodass das Endergebnis möglicherweise weniger als 50 beträgt.
Ressourcenkonkurrenz auflösen

from threading import Lock, Thread
lock=Lock()
some_var=0
   
classIncrementThread(Thread):
  defrun(self):
    #we want to read a global variable
    #and then increment it
    globalsome_var
    lock.acquire()
    read_value=some_var
    print”some_var in %s is %d”%(self.name, read_value)
    some_var=read_value+1
    print”some_var in %s after increment is %d”%(self.name, some_var)
    lock.release()
   
defuse_increment_thread():
  threads=[]
  foriinrange(50):
    t=IncrementThread()
    threads.append(t)
    t.start()
  fortinthreads:
    t.join()
  print”After 50 modifications, some_var should have become 50″
  print”After 50 modifications, some_var is %d”%(some_var,)
   
use_increment_thread()

Führen Sie dieses Programm erneut aus und erzielen Sie die erwarteten Ergebnisse.
Erklärung:
Sperre Wird verwendet, um Race-Bedingungen zu verhindern
Wenn Thread t1 die Sperre erhält, bevor er einige Vorgänge ausführt. Andere Threads führen den gleichen Vorgang nicht aus, bevor t1 die Sperre aufhebt
Wir möchten sicherstellen, dass, sobald Thread t1 some_var gelesen hat, andere Threads some_var nicht lesen können, bis t1 die Änderung von some_var abgeschlossen hat
Auf diese Weise lesen und das Ändern von some_var wird zu einer logischen atomaren Operation.
Beispiel 3
Lassen Sie uns anhand eines Beispiels beweisen, dass ein Thread keine Variablen (nicht globale Variablen) in anderen Threads beeinflussen kann.
time.sleep() kann einen Thread anhalten und einen Threadwechsel erzwingen.

from threading import Thread
import time
   
classCreateListThread(Thread):
  defrun(self):
    self.entries=[]
    foriinrange(10):
      time.sleep(1)
      self.entries.append(i)
    printself.entries
   
defuse_create_list_thread():
  foriinrange(3):
    t=CreateListThread()
    t.start()
   
use_create_list_thread()

Nach mehrmaligem Ausführen stellte ich fest, dass das gewünschte Ergebnis nicht ausgedruckt wurde. Während ein Thread druckt, wechselt die CPU zu einem anderen Thread, sodass falsche Ergebnisse erzeugt werden. Wir müssen sicherstellen, dass gedruckt wird self.entries ist eine logische atomare Operation, um zu verhindern, dass der Druckvorgang durch andere Threads unterbrochen wird.
Wir haben Lock() verwendet, sehen Sie sich das Beispiel unten an.

from threading import Thread, Lock
import time
   
lock=Lock()
   
classCreateListThread(Thread):
  defrun(self):
    self.entries=[]
    foriinrange(10):
      time.sleep(1)
      self.entries.append(i)
    lock.acquire()
    printself.entries
    lock.release()
   
defuse_create_list_thread():
  foriinrange(3):
    t=CreateListThread()
    t.start()
   
use_create_list_thread()

Diesmal haben wir das richtige Ergebnis gesehen. Es beweist, dass ein Thread die internen Variablen (nicht globale Variablen) anderer Threads nicht ändern kann.

Das Obige ist Multithreading in Python. Weitere verwandte Artikel finden Sie auf der chinesischen PHP-Website (www.php.cn)!