Effizienzvergleichsexperiment von Single-Thread, Multi-Thread und Multi-Prozess in Python

Vergleichsexperimente

Daten zeigen, dass Multithreading die Effizienz nicht wesentlich verbessert, wenn der Multithread-Prozess CPU-intensiv ist. Im Gegenteil, die Effizienz kann aufgrund des häufigen Threadwechsels abnehmen . Es wird empfohlen, einen Multiprozess zu verwenden. Wenn er IO-intensiv ist, kann der Multithread-Prozess die Leerlaufzeit nutzen, während er auf die IO-Blockierung wartet, um andere Threads auszuführen, um die Effizienz zu verbessern. Wir vergleichen also die Effizienz verschiedener Szenarien auf der Grundlage von Experimenten

|-----------|------. -|- -----|--------|.
| >

(2) CPU-intensive Berechnungsfunktionen definieren

import requests
import time
from threading import Thread
from multiprocessing import Process

(3) E/A-intensive Funktionen zum Lesen und Schreiben von Dateien definieren

def count(x, y):
    # 使程序完成150万计算
    c = 0
    while c < 500000:
        c += 1
        x += x
        y += y

(4) Definieren Netzwerkanforderungsfunktionen

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()

(5) Testen Sie die Zeit, die für die lineare Ausführung von E/A-intensiven Vorgängen, CPU-intensiven Vorgängen und Netzwerkanforderungsintensiven Vorgängen

_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}

Ausgabe

CPU-intensive: 95.6059999466, 91.57099986076355 92.52800011634827, 99.96799993515015

# 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)

IO intensive: 24.25, 21.76699995994568, 21.769999980926 514, 22.060999870300293

Network request intensive: 4.519999980926514, 8.563999891281128, 4.371000051498413, 4.522000074386597, 14.671000003 814697

(6 )Testen Sie die Zeit, die Multithreads benötigen, um gleichzeitig CPU-intensive Vorgänge auszuführen

Ausgabe: 99.9240000248, 101.26400017738342, 102.3220000267 0288

(7 ) Testen Sie die Zeit, die Multithreads für die gleichzeitige Ausführung von E/A-intensiven Vorgängen benötigen

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

(8) Testen Sie die Zeit, die für die gleichzeitige Ausführung von Multithreads erforderlich ist Netzwerkintensive Vorgänge

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: 0,7419998645782471, 0,38 39998245239258, 0,3900001049041748

(9) Testen Sie die Zeit, die mehrere Prozesse benötigen, um gleichzeitig CPU-intensive Vorgänge auszuführen

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: 54.342000007629395, 53.437999963760376

(10) Testen Sie mehrere Prozesse, um IO-intensive Vorgänge gleichzeitig auszuführen

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: 12.509000062942505, 13.0590 00015258789

(11) Testen der gleichzeitigen Ausführung von HTTP-Anforderungsintensiven Vorgängen durch mehrere Prozesse

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: 0,5329999923 706055, 0,4760000705718994

Experimentelle Ergebnisse

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)

Anhand der obigen Ergebnisse können wir sehen:

Multi-Threading scheint bei IO-intensiven Vorgängen nicht sehr wichtig zu sein (vielleicht werden sich die Vorteile widerspiegeln, wenn die IO-Operationsaufgabe schwerer ist). Bei CPU-intensiven Vorgängen ist die Leistung offensichtlich schlechter als bei der linearen Ausführung mit einem Thread. Bei Vorgängen wie Netzwerkanforderungen, bei denen beschäftigtes Warten den Thread blockiert, sind jedoch viele Die Vorteile von Threads sind sehr bedeutsam

Mehrere Prozesse können gezeigt werden Leistungsvorteile, egal ob CPU-intensiv, IO-intensiv oder netzwerkanforderungsintensiv (es kommt häufig zu Thread-Blockierungsvorgängen). Für netzwerkanforderungsintensive Vorgänge ist es jedoch fast dasselbe wie Multithreading, beansprucht jedoch mehr Ressourcen wie CPU. In diesem Fall können wir also Multithreading für die Ausführung auswählen