Введение в параллельное и параллельное программирование на Python

Так что Python не является действительно многопоточным. Но что это за нить? Давайте сделаем шаг назад и посмотрим на вещи в перспективе.

Процесс — это базовая абстракция операционной системы. Это программа, которая выполняется — другими словами, код, который выполняется. На компьютере всегда выполняется несколько процессов, и они выполняются параллельно.

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

Если это все еще немного неясно, вот чит-лист:

Нет ни одного рецепта, который бы подходил всем. Выбор одного зависит от контекста и задачи, которую вы пытаетесь достичь.

Теперь мы сделаем еще один шаг и погрузимся в параллелизм. Параллелизм часто неправильно понимают и ошибочно принимают за параллелизм. Это не тот случай. Параллельность подразумевает планирование независимого кода для совместного выполнения. Воспользуйтесь тем фактом, что часть кода ожидает выполнения операций ввода-вывода, и в течение этого времени запускайте другую, но независимую часть кода.

В Python мы можем добиться легкого параллельного поведения через гринлеты. С точки зрения распараллеливания использование потоков или гринлетов эквивалентно, поскольку ни один из них не работает параллельно. Гринлеты создавать даже дешевле, чем нитки. Из-за этого гринлеты активно используются для выполнения огромного количества простых задач ввода-вывода, подобных тем, которые обычно используются в сетевых и веб-серверах.

Теперь, когда мы знаем разницу между потоками и процессами, параллельными и параллельными, мы можем проиллюстрировать, как разные задачи выполняются в двух парадигмах. Вот что мы собираемся сделать: мы будем многократно запускать задачу вне GIL и одну внутри нее. Мы запускаем их последовательно, используя потоки и процессы. Давайте определим задачи:

Мы создали две задачи. Оба они работают долго, но только crunch_numbers активно выполняет вычисления. Давайте запустим only_sleep последовательно, многопоточно и с использованием нескольких процессов и сравним результаты:

Вот вывод, который я получил (ваш должен быть похожим, хотя PID и время будут немного отличаться):

Вот некоторые наблюдения:

• В случае последовательного подхода все довольно очевидно. Мы выполняем задачи одну за другой. Все четыре запуска выполняются одним и тем же потоком одного и того же процесса.

• Используя процессы, мы сокращаем время выполнения до четверти исходного времени просто потому, что задачи выполняются параллельно. Обратите внимание, как каждая задача выполняется в отдельном процессе и в MainThread этого процесса.

• Используя потоки, мы пользуемся тем фактом, что задачи могут выполняться одновременно. Время выполнения также сокращается до четверти, хотя параллельно ничего не происходит. Вот как это происходит: мы создаем первый поток, и он начинает ждать истечения таймера. Мы приостанавливаем его выполнение, даем ему подождать, пока истечет таймер, и за это время мы порождаем второй поток. Мы повторяем это для всех тем. В какой-то момент истекает таймер первого потока, поэтому мы переключаем на него выполнение и завершаем его. Алгоритм повторяется для второго и всех остальных потоков. В итоге получается, что все идет параллельно. Вы также заметите, что четыре разных потока ветвятся и живут в одном и том же процессе: MainProcess .

• Вы можете даже заметить, что многопоточный подход быстрее, чем действительно параллельный. Это связано с накладными расходами на нерестовые процессы. Как мы отмечали ранее, процессы порождения и переключения являются дорогостоящей операцией.

Давайте crunch_numbers ту же процедуру, но на этот раз crunch_numbers задачу crunch_numbers :

Вот результат, который я получил:

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

Python имеет богатые API для параллельного / параллельного программирования. В этом уроке мы рассмотрим самые популярные из них, но вы должны знать, что для любых ваших потребностей в этой области, возможно, уже есть что-то, что может помочь вам в достижении вашей цели.

В следующем разделе мы создадим практическое приложение во многих формах, используя все представленные библиотеки. Без лишних слов, вот модули / библиотеки, которые мы собираемся охватить:

• threading : стандартный способ работы с потоками в Python. Это высокоуровневая оболочка API для функциональности, _thread модулем _thread , который является низкоуровневым интерфейсом для реализации потоков операционной системы.

• concurrent.futures : модульная часть стандартной библиотеки, которая обеспечивает еще более высокий уровень абстракции над потоками. Потоки моделируются как асинхронные задачи.

• multiprocessing : аналогично модулю threading , с очень похожим интерфейсом, но использующим процессы вместо потоков.

• gevent and greenlets : Greenlets, также называемые микропотоками, являются единицами выполнения, которые могут планироваться совместно и могут выполнять задачи одновременно без больших накладных расходов.

• celery : распределенная очередь задач высокого уровня. Задачи ставятся в очередь и выполняются одновременно с использованием различных парадигм, таких как multiprocessing или gevent .

Знание теории — это хорошо и хорошо, но лучший способ научиться — это создать что-то практичное, верно? В этом разделе мы собираемся создать приложение классического типа, проходящее через все различные парадигмы.

Во-первых, давайте попробуем последовательный подход и посмотрим, насколько плохо он работает. Мы рассмотрим это как базовый уровень.

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

Как указывалось ранее, concurrent.futures — это высокоуровневый API для использования потоков. Подход, который мы здесь используем, подразумевает использование ThreadPoolExecutor . Мы собираемся отправить задачи в пул и вернуть фьючерсы, результаты которых будут нам доступны в будущем. Конечно, мы можем подождать, пока все фьючерсы станут фактическими результатами.

multiprocessing библиотека предоставляет API-интерфейс для замены threading . В этом случае мы собираемся использовать подход, более похожий на подход concurrent.futures . Мы настраиваем multiprocessing.Pool и отправляем ему задачи, отображая функцию в список адресов (вспомним классическую функцию map Python).

Gevent является популярной альтернативой для достижения массового параллелизма. Есть несколько вещей, которые вы должны знать, прежде чем использовать его:

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

• Вам нужно соединить стандартные функции, чтобы они взаимодействовали с Gevent. Вот что я имею в виду под этим. Обычно операция сокета блокируется. Мы ждем окончания операции. Если бы мы находились в многопоточной среде, планировщик просто переключился бы на другой поток, в то время как другой ожидает ввода / вывода. Поскольку мы не в многопоточной среде, gevent исправляет стандартные функции, чтобы они стали неблокирующими, и возвращал управление планировщику gevent.

Чтобы установить gevent, запустите: pip install gevent

Вот как использовать gevent для выполнения нашей задачи с помощью gevent.pool.Pool :

Сельдерей — это подход, который в основном отличается от того, что мы видели до сих пор. Это боевые испытания в условиях очень сложных и высокопроизводительных сред. Настройка Celery потребует немного больше усилий, чем все вышеперечисленные решения.

Для начала нам нужно установить Celery:

pip install celery

Задачи являются центральными понятиями в рамках проекта Celery. Все, что вы захотите запустить в Celery, должно быть задачей. Celery предлагает большую гибкость для запуска задач: вы можете запускать их синхронно или асинхронно, в режиме реального времени или по расписанию, на одной и той же машине или на нескольких машинах, используя потоки, процессы, Eventlet или Gevent.

Расположение будет немного сложнее. Сельдерей использует другие сервисы для отправки и получения сообщений. Эти сообщения обычно являются задачами или результатами задач. Мы собираемся использовать Redis в этом руководстве для этой цели. Redis — отличный выбор, потому что его действительно легко установить и настроить, и вполне возможно, что вы уже используете его в своем приложении для других целей, таких как кэширование и публикация / публикация.

Я надеюсь, что это было интересное путешествие для вас и хорошее введение в мир параллельного / параллельного программирования на Python. Это конец пути, и мы можем сделать некоторые выводы:

• Есть несколько парадигм, которые помогают нам достигать высокопроизводительных вычислений в Python.
• Для многопоточной парадигмы у нас есть библиотеки threading и concurrent.futures .
• multiprocessing обеспечивает очень похожий интерфейс на threading но для процессов, а не для потоков.
• Помните, что процессы достигают истинного параллелизма, но создавать их дороже.
• Помните, что в процессе может быть запущено больше потоков.
• Не путайте параллель с параллельной. Помните, что только параллельный подход использует преимущества многоядерных процессоров, в то время как параллельное программирование интеллектуально планирует задачи так, что ожидание длительных операций выполняется при параллельном выполнении реальных вычислений.

Выучить питон