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()
Die erneute Ausführung des Programms erzielte 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()
Nachdem ich es mehrmals ausgeführt hatte, stellte ich fest, dass die von mir angestrebten Ergebnisse nicht ausgedruckt wurden. 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()
Dieses Mal haben wir die richtigen Ergebnisse gesehen. Es beweist, dass ein Thread die internen Variablen (nicht globale Variablen) anderer Threads nicht ändern kann.
