Введение

Примеры

Глобальная блокировка интерпретатора

Python производительность многопоточной часто страдает из - за глобальным интерпретатор Замка . Короче говоря, даже если вы можете иметь несколько потоков в программе Python, только одна инструкция байт-кода может выполняться параллельно в любое время, независимо от количества процессоров.

Таким образом, многопоточность в случаях, когда операции блокируются внешними событиями, такими как доступ к сети, может быть довольно эффективной:

 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 

Обратите внимание , что даже если каждый process занимает 2 секунды , чтобы выполнить эти четыре процесса вместе были в состоянии эффективно работать параллельно, принимая всего 2 секунды.

Тем не менее, многопоточность в тех случаях, когда в коде Python выполняются интенсивные вычисления, такие как много вычислений, не приводит к значительным улучшениям и даже может быть медленнее, чем параллельная работа:

 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 

В последнем случае многопроцессорная обработка может быть эффективной, поскольку несколько процессов могут, конечно, выполнять несколько инструкций одновременно:

 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 

Запуск в нескольких потоках

Используйте threading.Thread запустить функцию в другом потоке.

 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 

Запуск в нескольких процессах

Используйте multiprocessing.Process для запуска функции в другом процессе. Интерфейс похож на 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 

Совместное использование состояния между потоками

Поскольку все потоки выполняются в одном и том же процессе, все потоки имеют доступ к одним и тем же данным.

Однако одновременный доступ к общим данным должен быть защищен блокировкой, чтобы избежать проблем с синхронизацией.

 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} 

Совместное использование состояния между процессами

Код, выполняемый в разных процессах, по умолчанию не разделяет одни и те же данные. Однако multiprocessing модуль содержит примитивы , чтобы помочь стоимость акций через несколько процессов.

 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 

Синтаксис

Параметры

Примечания