Python ist eine Sprache, die in einem Interpreter ausgeführt wird. Laut Untersuchungen hat Python eine globale Sperre (GIL). Bei Verwendung von Multithreading (Thread) können die Vorteile von Mehrkernprozessoren nicht genutzt werden. Die Verwendung von Multiprocessing (Multiprocess) kann jedoch die Vorteile von Mehrkernprozessoren nutzen, um die Effizienz wirklich zu verbessern.
Vergleichsexperiment
Den Informationen zufolge: Wenn der Multithread-ProzessCPU-intensivist, dann kann Multithreading die Effizienz nicht viel verbessern; im Gegenteil, sie kann aufgrund häufiger Thread-Wechsel sogar die Effizienz verringern, daher wird Multiprocessing empfohlen; wenn erIO-intensivdann können Multithread-Prozesse die Leerlaufzeit während IO-blockierender Wartezeiten nutzen, um andere Threads auszuführen, wodurch die Effizienz verbessert wird. Daher vergleichen wir die Effizienz verschiedener Szenarien durch Experimente.
| Betriebssystem | CPU | Gedächtnis | Festplatte |
|---|---|---|---|
| Windows 10 | Dual-Core | 8GB | Mechanische Festplatte |
(1) Importiere die erforderlichen Module
import requests import time from threading import Thread from multiprocessing import Process
(2) Definiere eine CPU-intensive Berechnungsfunktion
def count(x, y):
# 使程序完成50万计算
c = 0
while c < 500000:
c += 1
x += x
y += y
(3) Definiere eine IO-intensive Datei-Lese-/Schreibfunktion
def write():
f = open("test.txt", "w")
for x in range(5000000):
f.write("testwrite\n")
f.close()
def read():
f = open("test.txt", "r")
lines = f.readlines()
f.close()
(4) Definiere eine Netzwerkanfragefunktion
_head = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.116 Safari/537.36'}
url = "http://www.tieba.com"
def http_request():
try:
webPage = requests.get(url, headers=_head)
html = webPage.text
return {"context": html}
except Exception as e:
return {"error": e}
(5) Teste die benötigte Zeit für die lineare Ausführung von IO-intensiven Operationen, CPU-intensiven Operationen und netzwerkanfrageintensiven Operationen
# CPU密集操作
t = time.time()
for x in range(10):
count(1, 1)
print("Line cpu", time.time() - t)
# IO密集操作
t = time.time()
for x in range(10):
write()
read()
print("Line IO", time.time() - t)
# 网络请求密集型操作
t = time.time()
for x in range(10):
http_request()
print("Line Http Request", time.time() - t)
Ausgabe
CPU-intensiv: 95.6059999466, 91.57099986076355, 92.52800011634827, 99.96799993515015
IO-intensiv: 24.25, 21.76699995994568, 21.769999980926514, 22.060999870300293
Netzwerkanfrage-intensiv: 4.519999980926514, 8.563999891281128, 4.371000051498413, 4.522000074386597, 14.671000003814697
(6) Teste die benötigte Zeit für die nebenläufige Multithread-Ausführung von CPU-intensiven Operationen
counts = []
t = time.time()
for x in range(10):
thread = Thread(target=count, args=(1,1))
counts.append(thread)
thread.start()
e = counts.__len__()
while True:
for th in counts:
if not th.is_alive():
e -= 1
if e <= 0:
break
print(time.time() - t)
Ausgabe: 25.69700002670288、24.02400016784668
(7) Teste die benötigte Zeit für die nebenläufige Multithread-Ausführung von IO-intensiven Operationen
def io():
write()
read()
t = time.time()
ios = []
t = time.time()
for x in range(10):
thread = Thread(target=count, args=(1,1))
ios.append(thread)
thread.start()
e = ios.__len__()
while True:
for th in ios:
if not th.is_alive():
e -= 1
if e <= 0:
break
print(time.time() - t)
Ausgabe: 99.9240000248 、101.26400017738342、102.32200002670288
(8) Testen Sie den Zeitaufwand für die nebenläufige Multithread-Ausführung netzwerkintensiver Operationen
t = time.time()
ios = []
t = time.time()
for x in range(10):
thread = Thread(target=http_request)
ios.append(thread)
thread.start()
e = ios.__len__()
while True:
for th in ios:
if not th.is_alive():
e -= 1
if e <= 0:
break
print("Thread Http Request", time.time() - t)
Ausgabe: 0.7419998645782471、0.3839998245239258、0.3900001049041748
(9) Testen Sie den Zeitaufwand für die nebenläufige Mehrprozess-Ausführung CPU-intensiver Operationen
counts = []
t = time.time()
for x in range(10):
process = Process(target=count, args=(1,1))
counts.append(process)
process.start()
e = counts.__len__()
while True:
for th in counts:
if not th.is_alive():
e -= 1
if e <= 0:
break
print("Multiprocess cpu", time.time() - t)
Ausgabe: 54.342000007629395、53.437999963760376
(10) Testen Sie die nebenläufige Mehrprozess-Ausführung IO-intensiver Operationen
t = time.time()
ios = []
t = time.time()
for x in range(10):
process = Process(target=io)
ios.append(process)
process.start()
e = ios.__len__()
while True:
for th in ios:
if not th.is_alive():
e -= 1
if e <= 0:
break
print("Multiprocess IO", time.time() - t)
Ausgabe: 12.509000062942505、13.059000015258789
(11) Testen Sie die nebenläufige Mehrprozess-Ausführung HTTP-anfrageintensiver Operationen
t = time.time()
httprs = []
t = time.time()
for x in range(10):
process = Process(target=http_request)
ios.append(process)
process.start()
e = httprs.__len__()
while True:
for th in httprs:
if not th.is_alive():
e -= 1
if e <= 0:
break
print("Multiprocess Http Request", time.time() - t)
Ausgabe: 0.5329999923706055、0.4760000705718994
Experimentelle Ergebnisse
| CPU-intensive Operationen | IO-intensive Operationen | Netzwerk-anfrageintensive Operationen | |
|---|---|---|---|
| Lineare Operationen | 94.91824996469 | 22.46199995279 | 7.3296000004 |
| Multithread-Operationen | 101.1700000762 | 24.8605000973 | 0.5053332647 |
| Multiprozess-Operationen | 53.8899999857 | 12.7840000391 | 0.5045000315 |
Aus den obigen Ergebnissen können wir sehen:
Multithreading scheint auch bei IO-intensiven Operationen keinen signifikanten Vorteil zu haben (vielleicht würde sich der Vorteil zeigen, wenn die IO-Aufgaben schwerer wären). Bei CPU-intensiven Operationen ist es eindeutig schlechter als die lineare Ausführung mit einem einzelnen Thread. Für Operationen wie Netzwerkanfragen, die zu Busy-Wait-Thread-Blockierungen führen, hat Multithreading jedoch einen sehr signifikanten Vorteil.
Multiprozess zeigt Leistungsvorteile in CPU-intensiven, IO-intensiven und netzwerkanfrage-intensiven (Operationen, bei denen häufig Thread-Blockierungen auftreten) Szenarien. Für Operationen, die den netzwerkanfrage-intensiven ähneln, ist es jedoch fast identisch mit Multithreading, verbraucht aber mehr Ressourcen wie CPU. Daher können wir in diesem Fall Multithreading zur Ausführung wählen.

Originaladresse: http://blog.atomicer.cn/2016/09/30/Python%E4%B8%AD%E5%A4%9A%E7%BA%BF%E7%A8%8B%E5%92%8C%E5%A4%9A%E8%BF%9B%E7%A8%8B%E7%9A%84%E5%AF%B9%E6%AF%94/