Розблокування паралелізму в Python: ThreadPoolExecutor проти ProcessPoolExecutor

Python, будучи універсальною та широко використовуваною мовою програмування, має певні обмеження, коли справа доходить до справжнього паралелізму через глобальне блокування інтерпретатора (GIL). Модуль concurrent.futures надає високорівневий інтерфейс для асинхронного виконання викликів, пропонуючи спосіб обійти деякі з цих обмежень і покращити продуктивність для певних типів завдань. Цей модуль надає два ключові класи: ThreadPoolExecutor і ProcessPoolExecutor. Цей вичерпний посібник досліджуватиме обидва, висвітлюючи їх відмінності, сильні та слабкі сторони, а також надаючи практичні приклади, щоб допомогти вам вибрати правильний виконавець для ваших потреб.

Розуміння паралелізму та конкурентності

Перш ніж заглиблюватися в специфіку кожного виконавця, важливо зрозуміти поняття паралелізму та конкурентності. Ці терміни часто використовуються як взаємозамінні, але вони мають різні значення:

• Конкурентність: Має справу з управлінням кількома завданнями одночасно. Йдеться про структурування вашого коду для обробки кількох речей, що відбуваються нібито одночасно, навіть якщо вони фактично чергуються на одному ядрі процесора. Уявіть собі шеф-кухаря, який керує кількома каструлями на одній плиті – вони не киплять в *той самий* момент, але шеф-кухар керує ними всіма.
• Паралелізм: Передбачає фактичне виконання кількох завдань *одночасно*, як правило, за допомогою кількох ядер процесора. Це як мати кількох шеф-кухарів, кожен з яких одночасно працює над різною частиною страви.

GIL Python значною мірою запобігає справжньому паралелізму для завдань, обмежених CPU, під час використання потоків. Це тому, що GIL дозволяє лише одному потоку контролювати інтерпретатор Python у будь-який момент часу. Однак, для завдань, обмежених вводом-виводом, де програма проводить більшу частину свого часу в очікуванні зовнішніх операцій, таких як мережеві запити або читання з диска, потоки все ще можуть забезпечити значне підвищення продуктивності, дозволяючи іншим потокам працювати, поки один очікує.

Представляємо модуль `concurrent.futures`

Модуль concurrent.futures спрощує процес асинхронного виконання завдань. Він надає високорівневий інтерфейс для роботи з потоками та процесами, абстрагуючи більшу частину складності, пов’язаної з безпосереднім управлінням ними. Основною концепцією є «виконавець», який керує виконанням надісланих завдань. Двома основними виконавцями є:

• ThreadPoolExecutor: Використовує пул потоків для виконання завдань. Підходить для завдань, обмежених вводом-виводом.
• ProcessPoolExecutor: Використовує пул процесів для виконання завдань. Підходить для завдань, обмежених CPU.

ThreadPoolExecutor: Використання потоків для завдань, обмежених вводом-виводом

ThreadPoolExecutor створює пул робочих потоків для виконання завдань. Через GIL потоки не ідеальні для обчислювально інтенсивних операцій, які виграють від справжнього паралелізму. Однак вони чудово підходять для сценаріїв, обмежених вводом-виводом. Давайте розглянемо, як його використовувати:

Основне використання

Ось простий приклад використання ThreadPoolExecutor для одночасного завантаження кількох веб-сторінок:

import concurrent.futures
import requests
import time

urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
    "https://www.python.org"
]


def download_page(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        print(f"Downloaded {url}: {len(response.content)} bytes")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Error downloading {url}: {e}")
        return 0


start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # Submit each URL to the executor
    futures = [executor.submit(download_page, url) for url in urls]

    # Wait for all tasks to complete
    total_bytes = sum(future.result() for future in concurrent.futures.as_completed(futures))

print(f"Total bytes downloaded: {total_bytes}")
print(f"Time taken: {time.time() - start_time:.2f} seconds")

Пояснення:

1. Ми імпортуємо необхідні модулі: concurrent.futures, requests і time.
2. Ми визначаємо список URL-адрес для завантаження.
3. Функція download_page отримує вміст заданої URL-адреси. Обробка помилок включена за допомогою `try...except` і `response.raise_for_status()` для виявлення потенційних мережевих проблем.
4. Ми створюємо ThreadPoolExecutor з максимум 4 робочими потоками. Аргумент max_workers контролює максимальну кількість потоків, які можна використовувати одночасно. Встановлення його занадто високим не завжди може покращити продуктивність, особливо для завдань, обмежених вводом-виводом, де пропускна здатність мережі часто є вузьким місцем.
5. Ми використовуємо генератор списку, щоб надіслати кожну URL-адресу виконавцю за допомогою executor.submit(download_page, url). Це повертає об’єкт Future для кожного завдання.
6. Функція concurrent.futures.as_completed(futures) повертає ітератор, який повертає futures у міру їх завершення. Це дозволяє уникнути очікування завершення всіх завдань перед обробкою результатів.
7. Ми перебираємо завершені futures і отримуємо результат кожного завдання за допомогою future.result(), підсумовуючи загальну кількість завантажених байтів. Обробка помилок у межах `download_page` гарантує, що окремі збої не призведуть до збою всього процесу.
8. Нарешті, ми друкуємо загальну кількість завантажених байтів і витрачений час.

Переваги ThreadPoolExecutor

• Спрощений паралелізм: Надає чистий і простий у використанні інтерфейс для керування потоками.
• Продуктивність, обмежена вводом-виводом: Чудово підходить для завдань, які витрачають значний час на очікування операцій вводу-виводу, таких як мережеві запити, читання файлів або запити до бази даних.
• Зменшення накладних витрат: Потоки, як правило, мають менші накладні витрати порівняно з процесами, що робить їх більш ефективними для завдань, які включають часте перемикання контексту.

Обмеження ThreadPoolExecutor

• Обмеження GIL: GIL обмежує справжній паралелізм для завдань, обмежених CPU. Лише один потік може виконувати байт-код Python одночасно, що зводить нанівець переваги кількох ядер.
• Складність налагодження: Налагодження багатопотокових програм може бути складним через умови гонки та інші проблеми, пов’язані з паралелізмом.

ProcessPoolExecutor: Розкриття багатопроцесорності для завдань, обмежених CPU

ProcessPoolExecutor долає обмеження GIL, створюючи пул робочих процесів. Кожен процес має власний інтерпретатор Python і простір пам’яті, що дозволяє справжній паралелізм у багатоядерних системах. Це робить його ідеальним для завдань, обмежених CPU, які включають важкі обчислення.

Основне використання

Розглянемо обчислювально інтенсивне завдання, як-от обчислення суми квадратів для великого діапазону чисел. Ось як використовувати ProcessPoolExecutor для паралелізації цього завдання:

import concurrent.futures
import time
import os

def sum_of_squares(start, end):
    pid = os.getpid()
    print(f"Process ID: {pid}, Calculating sum of squares from {start} to {end}")
    total = 0
    for i in range(start, end + 1):
        total += i * i
    return total


if __name__ == "__main__": #Important for avoiding recursive spawning in some environments
    start_time = time.time()
    range_size = 1000000
    num_processes = 4
    ranges = [(i * range_size + 1, (i + 1) * range_size) for i in range(num_processes)]

    with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
        futures = [executor.submit(sum_of_squares, start, end) for start, end in ranges]
        results = [future.result() for future in concurrent.futures.as_completed(futures)]

    total_sum = sum(results)
    print(f"Total sum of squares: {total_sum}")
    print(f"Time taken: {time.time() - start_time:.2f} seconds")

Пояснення:

1. Ми визначаємо функцію sum_of_squares, яка обчислює суму квадратів для заданого діапазону чисел. Ми включаємо `os.getpid()`, щоб побачити, який процес виконує кожен діапазон.
2. Ми визначаємо розмір діапазону та кількість процесів для використання. Список ranges створюється для поділу загального діапазону обчислень на менші частини, по одній для кожного процесу.
3. Ми створюємо ProcessPoolExecutor із зазначеною кількістю робочих процесів.
4. Ми надсилаємо кожен діапазон виконавцю за допомогою executor.submit(sum_of_squares, start, end).
5. Ми збираємо результати від кожного future за допомогою future.result().
6. Ми підсумовуємо результати від усіх процесів, щоб отримати остаточну суму.

Важлива примітка: Під час використання ProcessPoolExecutor, особливо в Windows, слід вкладати код, який створює executor, у блок if __name__ == "__main__":. Це запобігає рекурсивному породженню процесів, що може призвести до помилок і несподіваної поведінки. Це тому, що модуль повторно імпортується в кожному дочірньому процесі.

Переваги ProcessPoolExecutor

• Справжній паралелізм: Долає обмеження GIL, дозволяючи справжній паралелізм у багатоядерних системах для завдань, обмежених CPU.
• Покращена продуктивність для завдань, обмежених CPU: Можна досягти значного підвищення продуктивності для обчислювально інтенсивних операцій.
• Надійність: Якщо один процес аварійно завершує роботу, це не обов’язково призводить до збою всієї програми, оскільки процеси ізольовані один від одного.

Обмеження ProcessPoolExecutor

• Вищі накладні витрати: Створення процесів і управління ними має вищі накладні витрати порівняно з потоками.
• Міжпроцесорний зв’язок: Обмін даними між процесами може бути складнішим і вимагає механізмів міжпроцесорного зв’язку (IPC), що може збільшити накладні витрати.
• Використання пам’яті: Кожен процес має власний простір пам’яті, що може збільшити загальний обсяг пам’яті програми. Передача великої кількості даних між процесами може стати вузьким місцем.

Вибір правильного виконавця: ThreadPoolExecutor проти ProcessPoolExecutor

Ключ до вибору між ThreadPoolExecutor і ProcessPoolExecutor полягає в розумінні природи ваших завдань:

• Завдання, обмежені вводом-виводом: Якщо ваші завдання проводять більшу частину свого часу в очікуванні операцій вводу-виводу (наприклад, мережеві запити, читання файлів, запити до бази даних), ThreadPoolExecutor зазвичай є кращим вибором. GIL менше обмежує в цих сценаріях, а менші накладні витрати потоків роблять їх більш ефективними.
• Завдання, обмежені CPU: Якщо ваші завдання є обчислювально інтенсивними та використовують кілька ядер, ProcessPoolExecutor — це те, що вам потрібно. Він обходить обмеження GIL і дозволяє справжній паралелізм, що призводить до значного підвищення продуктивності.

Ось таблиця, яка підсумовує ключові відмінності:

Функція	ThreadPoolExecutor	ProcessPoolExecutor
Модель паралелізму	Багатопотоковість	Багатопроцесорність
Вплив GIL	Обмежено GIL	Обходить GIL
Підходить для	Завдання, обмежені вводом-виводом	Завдання, обмежені CPU
Накладні витрати	Нижчі	Вищі
Використання пам’яті	Нижче	Вище
Міжпроцесорний зв’язок	Не потрібно (потоки використовують спільну пам’ять)	Потрібно для обміну даними
Надійність	Менш надійний (аварійне завершення може вплинути на весь процес)	Більш надійний (процеси ізольовані)

Розширені методи та міркування

Надсилання завдань з аргументами

Обидва виконавці дозволяють передавати аргументи функції, що виконується. Це робиться за допомогою методу submit():

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function, arg1, arg2)
    result = future.result()

Обробка винятків

Винятки, викликані у функції, що виконується, автоматично не передаються в основний потік або процес. Вам потрібно явно обробити їх під час отримання результату Future:

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function)
    try:
        result = future.result()
    except Exception as e:
        print(f"An exception occurred: {e}")

Використання `map` для простих завдань

Для простих завдань, де потрібно застосувати ту саму функцію до послідовності вхідних даних, метод map() надає стислий спосіб надсилання завдань:

def square(x):
    return x * x


with concurrent.futures.ProcessPoolExecutor() as executor:
    numbers = [1, 2, 3, 4, 5]
    results = executor.map(square, numbers)
    print(list(results))

Контроль кількості працівників

Аргумент max_workers як у ThreadPoolExecutor, так і в ProcessPoolExecutor контролює максимальну кількість потоків або процесів, які можна використовувати одночасно. Вибір правильного значення для max_workers важливий для продуктивності. Гарною відправною точкою є кількість ядер ЦП, доступних у вашій системі. Однак для завдань, обмежених вводом-виводом, ви можете отримати вигоду від використання більшої кількості потоків, ніж ядер, оскільки потоки можуть перемикатися на інші завдання під час очікування вводу-виводу. Експерименти та профілювання часто необхідні для визначення оптимального значення.

Моніторинг прогресу

Модуль concurrent.futures не надає вбудованих механізмів для безпосереднього моніторингу прогресу завдань. Однак ви можете реалізувати власне відстеження прогресу за допомогою зворотних викликів або спільних змінних. Такі бібліотеки, як `tqdm`, можна інтегрувати для відображення панелей прогресу.

Реальні приклади

Розглянемо деякі реальні сценарії, де ThreadPoolExecutor і ProcessPoolExecutor можна ефективно застосувати:

• Веб-скрапінг: Одночасне завантаження та аналіз кількох веб-сторінок за допомогою ThreadPoolExecutor. Кожен потік може обробляти іншу веб-сторінку, покращуючи загальну швидкість скрапінгу. Пам’ятайте про умови використання веб-сайту та уникайте перевантаження їхніх серверів.
• Обробка зображень: Застосування фільтрів або перетворень зображень до великого набору зображень за допомогою ProcessPoolExecutor. Кожен процес може обробляти інше зображення, використовуючи кілька ядер для швидшої обробки. Розгляньте такі бібліотеки, як OpenCV для ефективного маніпулювання зображеннями.
• Аналіз даних: Виконання складних обчислень над великими наборами даних за допомогою ProcessPoolExecutor. Кожен процес може аналізувати підмножину даних, скорочуючи загальний час аналізу. Pandas і NumPy є популярними бібліотеками для аналізу даних у Python.
• Машинне навчання: Навчання моделей машинного навчання за допомогою ProcessPoolExecutor. Деякі алгоритми машинного навчання можна ефективно паралелізувати, що дозволяє скоротити час навчання. Такі бібліотеки, як scikit-learn і TensorFlow, пропонують підтримку паралелізації.
• Кодування відео: Перетворення відеофайлів у різні формати за допомогою ProcessPoolExecutor. Кожен процес може кодувати інший сегмент відео, роблячи загальний процес кодування швидшим.

Глобальні міркування

Під час розробки паралельних програм для глобальної аудиторії важливо враховувати наступне:

• Часові пояси: Пам’ятайте про часові пояси, коли маєте справу з операціями, чутливими до часу. Використовуйте такі бібліотеки, як pytz, для обробки перетворень часових поясів.
• Локалі: Переконайтеся, що ваша програма правильно обробляє різні локалі. Використовуйте такі бібліотеки, як locale, для форматування чисел, дат і валют відповідно до локалі користувача.
• Кодування символів: Використовуйте Unicode (UTF-8) як кодування символів за замовчуванням для підтримки широкого спектру мов.
• Інтернаціоналізація (i18n) і локалізація (l10n): Розробіть свою програму так, щоб її можна було легко інтернаціоналізувати та локалізувати. Використовуйте gettext або інші бібліотеки перекладів, щоб надавати переклади для різних мов.
• Затримка мережі: Враховуйте затримку мережі під час зв’язку з віддаленими службами. Реалізуйте відповідні тайм-аути та обробку помилок, щоб забезпечити стійкість вашої програми до проблем із мережею. Географічне розташування серверів може значно вплинути на затримку. Розгляньте можливість використання мереж доставки вмісту (CDN) для покращення продуктивності для користувачів у різних регіонах.

Висновок

Модуль concurrent.futures надає потужний і зручний спосіб запровадити паралелізм у ваші програми Python. Розуміючи відмінності між ThreadPoolExecutor і ProcessPoolExecutor і ретельно враховуючи характер ваших завдань, ви можете значно покращити продуктивність і чуйність вашого коду. Не забувайте профілювати свій код і експериментувати з різними конфігураціями, щоб знайти оптимальні налаштування для вашого конкретного випадку використання. Крім того, пам’ятайте про обмеження GIL і потенційну складність багатопотокового та багатопроцесорного програмування. Завдяки ретельному плануванню та реалізації ви можете розкрити весь потенціал паралелізму в Python і створювати надійні та масштабовані програми для глобальної аудиторії.