Python Language
Procesy i wątki

Wprowadzenie

Globalna blokada tłumacza

Wydajność wielowątkowości w Pythonie może często ucierpieć z powodu blokady globalnego interpretera . Krótko mówiąc, nawet jeśli w programie Python można mieć wiele wątków, tylko jedna instrukcja kodu bajtowego może być wykonywana równolegle w tym samym czasie, niezależnie od liczby procesorów.

W związku z tym wielowątkowość w przypadkach, w których operacje są blokowane przez zdarzenia zewnętrzne - takie jak dostęp do sieci - może być dość skuteczna:

import threading
import time


def process():
    time.sleep(2)


start = time.time()
process()
print("One run took %.2fs" % (time.time() - start))


start = time.time()
threads = [threading.Thread(target=process) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print("Four runs took %.2fs" % (time.time() - start))

# Out: One run took 2.00s
# Out: Four runs took 2.00s

Zauważ, że chociaż wykonanie każdego process trwało 2 sekundy, cztery procesy razem mogły skutecznie działać równolegle, co łącznie zajęło 2 sekundy.

Jednak wielowątkowość w przypadkach, w których wykonywane są intensywne obliczenia w kodzie Pythona - takie jak wiele obliczeń - nie powoduje znacznej poprawy, a nawet może być wolniejsza niż równoległe:

import threading
import time


def somefunc(i):
    return i * i

def otherfunc(m, i):
    return m + i

def process():
    for j in range(100):
        result = 0
        for i in range(100000):
            result = otherfunc(result, somefunc(i))


start = time.time()
process()
print("One run took %.2fs" % (time.time() - start))


start = time.time()
threads = [threading.Thread(target=process) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print("Four runs took %.2fs" % (time.time() - start))

# Out: One run took 2.05s
# Out: Four runs took 14.42s

W tym ostatnim przypadku przetwarzanie wieloprocesowe może być skuteczne, ponieważ wiele procesów może oczywiście wykonywać wiele instrukcji jednocześnie:

import multiprocessing
import time


def somefunc(i):
    return i * i

def otherfunc(m, i):
    return m + i

def process():
    for j in range(100):
        result = 0
        for i in range(100000):
            result = otherfunc(result, somefunc(i))


start = time.time()
process()
print("One run took %.2fs" % (time.time() - start))


start = time.time()
processes = [multiprocessing.Process(target=process) for _ in range(4)]
for p in processes:
    p.start()
for p in processes:
    p.join()
print("Four runs took %.2fs" % (time.time() - start))

# Out: One run took 2.07s
# Out: Four runs took 2.30s

Działa w wielu wątkach

Użyj threading.Thread uruchomić funkcję w innym wątku.

import threading
import os

def process():
    print("Pid is %s, thread id is %s" % (os.getpid(), threading.current_thread().name))

threads = [threading.Thread(target=process) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
    
# Out: Pid is 11240, thread id is Thread-1
# Out: Pid is 11240, thread id is Thread-2
# Out: Pid is 11240, thread id is Thread-3
# Out: Pid is 11240, thread id is Thread-4

Uruchamianie w wielu procesach

Użyj multiprocessing.Process aby uruchomić funkcję w innym procesie. Interfejs jest podobny do threading.Thread .

import multiprocessing
import os

def process():
    print("Pid is %s" % (os.getpid(),))

processes = [multiprocessing.Process(target=process) for _ in range(4)]
for p in processes:
    p.start()
for p in processes:
    p.join()
    
# Out: Pid is 11206
# Out: Pid is 11207
# Out: Pid is 11208
# Out: Pid is 11209

Stan udostępniania między wątkami

Ponieważ wszystkie wątki działają w tym samym procesie, wszystkie wątki mają dostęp do tych samych danych.

Jednak równoczesny dostęp do udostępnionych danych powinien być chroniony blokadą, aby uniknąć problemów z synchronizacją.

import threading

obj = {}
obj_lock = threading.Lock()

def objify(key, val):
    print("Obj has %d values" % len(obj))
    with obj_lock:
        obj[key] = val
    print("Obj now has %d values" % len(obj))

ts = [threading.Thread(target=objify, args=(str(n), n)) for n in range(4)]
for t in ts:
    t.start()
for t in ts:
    t.join()
print("Obj final result:")
import pprint; pprint.pprint(obj)

# Out: Obj has 0 values
# Out:  Obj has 0 values
# Out: Obj now has 1 values
# Out: Obj now has 2 valuesObj has 2 values
# Out: Obj now has 3 values
# Out: 
# Out:  Obj has 3 values
# Out: Obj now has 4 values
# Out: Obj final result:
# Out: {'0': 0, '1': 1, '2': 2, '3': 3}

Stan udostępniania między procesami

Kod działający w różnych procesach domyślnie nie udostępnia tych samych danych. Jednak moduł multiprocessing zawiera operacje podstawowe, które pomagają współdzielić wartości w wielu procesach.

import multiprocessing

plain_num = 0
shared_num = multiprocessing.Value('d', 0)
lock = multiprocessing.Lock()

def increment():
    global plain_num
    with lock:
        # ordinary variable modifications are not visible across processes
        plain_num += 1
        # multiprocessing.Value modifications are
        shared_num.value += 1

ps = [multiprocessing.Process(target=increment) for n in range(4)]
for p in ps:
    p.start()
for p in ps:
    p.join()

print("plain_num is %d, shared_num is %d" % (plain_num, shared_num.value))

# Out: plain_num is 0, shared_num is 4