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/